package com.wicket.okrcomponent.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateUtil;
import com.wicket.okrcomponent.biz.service.dto.req.*;
import com.wicket.okrcomponent.biz.service.dto.res.*;
import com.wicket.okrcomponent.common.exception.BizException;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import com.wicket.okrcomponent.common.util.RedisUtil;

import java.sql.Date;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrcomponent.biz.service.dto.common.BusinessDataSetDto;
import com.wicket.okrcomponent.common.exception.Assert;
import com.wicket.okrcomponent.biz.service.InterfaceModeService;
import com.wicket.okrcomponent.biz.service.BusinessAtomService;
import com.wicket.okrcomponent.biz.service.ConfSchemeService;
import com.wicket.okrcomponent.base.service.MCustomFields3Service;
import com.wicket.okrcomponent.biz.service.nb.NbEvaCalc;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class EvaCalcServiceImpl
  implements com.wicket.okrcomponent.biz.service.EvaCalcService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private BusinessAtomService businessAtomService;
@Resource
  private ConfSchemeService confSchemeService;
@Resource
  private MCustomFields3Service mCustomFields3Service;
@Resource
  private NbEvaCalc nbEvaCalc;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
/**
   * D2更新分段查询Redis记录(公共)[9679]
   * gen by moon at 6/23/2024, 7:08:02 AM
   */
  @Trace(operationName = "D2更新分段查询Redis记录(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordCom(RefreshSegQueryRedisRecordComReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getBusinessDataSetList() !=null && reqDto.getBusinessDataSetList().size()>0)) {
        //if(D2更新分段查询Redis记录(公共).业务数据对象列表数据集条数 大于 0)  69355
        
ImplementDatasSetFetchLastLatestComRespDto implementDatasSetFetchLastLatestComRespDto = null;
    ImplementDatasSetFetchLastLatestComReqDto implementDatasSetFetchLastLatestComReqDto=new ImplementDatasSetFetchLastLatestComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getBusinessDataSetList()) {
                BusinessDataSetDto oneItem = new BusinessDataSetDto();
                if(reqDto!=null){
      oneItem.setCustomField1(item);//SimpleFieldAssign//sourceId:367324_2_69356
    }
               
                implementDatasSetFetchLastLatestComReqDto.getBusinessDataSetList().add(oneItem);
            }//sourceId:1826987_1_69356
    }
  
    /*D2执行数据集取最后一条(公共)[9408]   */
    
      implementDatasSetFetchLastLatestComRespDto = interfaceModeService.implementDatasSetFetchLastLatestCom(implementDatasSetFetchLastLatestComReqDto)/*vcase invoke isSameApp*/;
      
      
      
if((reqDto!= null&& reqDto.getLastDataObjectId() == null )) {
        //if(D2更新分段查询Redis记录(公共).最后一条数据对象ID 值等于空 )  69357
        
AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(implementDatasSetFetchLastLatestComRespDto !=null){
          AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setIsDataList("FALSE");//sourceId:1827219_1_69359
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("TRUE");//sourceId:1827216_1_69359
addRedisBusinessDataSetComReqDto.setDuration(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1827217_1_69359
addRedisBusinessDataSetComReqDto.setTimeUnitType("HOUR");//sourceId:1827218_1_69359
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1827211_1_69359
addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827213_1_69359
addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827212_1_69359
addRedisBusinessDataSetComReqDto.setCustomField1(reqDto.getBusinessDataSetPrimaryKeyName());//SimpleFieldAssign//sourceId:1827214_1_69359
    }
if(implementDatasSetFetchLastLatestComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue1(implementDatasSetFetchLastLatestComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1827215_1_69359
    }
  
    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getDuration(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-锁定时长不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getTimeUnitType(),"D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-时间单位类型不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
      }
else if((reqDto!= null&& reqDto.getLastDataObjectId() != null )){
       //elseif(D2更新分段查询Redis记录(公共).最后一条数据对象ID 值不等于空 )  69358
      
UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
    if(implementDatasSetFetchLastLatestComRespDto !=null){
    UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto.setIsDataList("FALSE");//sourceId:1827226_1_69360
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1827224_1_69360
updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827225_1_69360
updateRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827223_1_69360
updateRedisBusinessDataSetComReqDto.setCustomField1(reqDto.getBusinessDataSetPrimaryKeyName());//SimpleFieldAssign//sourceId:1827227_1_69360
    }
if(implementDatasSetFetchLastLatestComRespDto!=null){
updateRedisBusinessDataSetComReqDto.setCustomFieldValue1(implementDatasSetFetchLastLatestComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1827228_1_69360
    }
  
    /*D2修改redis业务数据对象(业务原子)[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(),"D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-是否是数据集对象不能为空",false);
      updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    }
      }
RefreshSegQueryRedisRecordComRespDto retData = new RefreshSegQueryRedisRecordComRespDto();
  
  

  
  
return retData;
  }
/**
   * D2新增规划目标计算MQ遥控器(公共)[9690]
   * gen by moon at 6/9/2024, 9:35:30 PM
   */
  @Trace(operationName = "D2新增规划目标计算MQ遥控器(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanTargetCalcMqRemoteControllerComRespDto addPlanTargetCalcMqRemoteControllerCom(AddPlanTargetCalcMqRemoteControllerComReqDto reqDto){


      //virtualUsage M2接收入参字段  69467
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1834890_1_69467
if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831279_1_69467
receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1831280_1_69467
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1831278_1_69467
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationSubjectId(),"D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价主题ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getOperateTime(),"D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



//virtualUsage D2系统当前操作时间  69750
      ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(receptionServiceRes!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(receptionServiceRes.getOperateTime()!=null?String.valueOf(receptionServiceRes.getOperateTime()):"");//SimpleFieldAssign//sourceId:1855409_1_69750
    }

    /*D2系统当前操作时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D2新增规划目标计算MQ遥控器(公共)-D2系统当前操作时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）  69490
      QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
    QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto=new QuerySingleRemoteControllerRedisDetailComReqDto();
  querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839420_1_69490
querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839421_1_69490
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839422_1_69490
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861431_1_69490
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue2("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1861432_1_69490
if(reqDto!=null){
      querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839423_1_69490
    }

    /*D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）[9708]   */
    Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-业务数据对象不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-Redis数据对象目录不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段值1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField2(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段2不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue2(),"D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段值2不能为空",false);
      querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((querySingleRemoteControllerRedisDetailComRespDto!= null&& querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null )) {
        //if(D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）.评价模板ID 值等于空 )  69426

ImplementPreEvaTempConfEntParameterComRespDto implementPreEvaTempConfEntParameterComRespDto = null;
    ImplementPreEvaTempConfEntParameterComReqDto implementPreEvaTempConfEntParameterComReqDto=new ImplementPreEvaTempConfEntParameterComReqDto();
  if(reqDto!=null){
      implementPreEvaTempConfEntParameterComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831223_1_69428
implementPreEvaTempConfEntParameterComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1831224_1_69428
implementPreEvaTempConfEntParameterComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1831225_1_69428
    }

    /*D2准备评价模板配置入参(公共)[8567]   */
    Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationTemplateId(),"D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-评价模板ID不能为空",false);
Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationSubjectId(),"D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-评价主题ID不能为空",false);
Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getSpaceId(),"D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-创建于空间ID不能为空",false);
      implementPreEvaTempConfEntParameterComRespDto = confSchemeService.implementPreEvaTempConfEntParameterCom(implementPreEvaTempConfEntParameterComReqDto)/*vcase invoke isSameApp*/;



AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(implementTimeFormatConversionComRespDto !=null&&implementPreEvaTempConfEntParameterComRespDto !=null){
          AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831198_1_69427
addRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1831095_1_69427
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1831197_1_69427
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831094_1_69427
addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831096_1_69427
addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831098_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1831099_1_69427
addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831100_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1831101_1_69427
addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1831419_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1831420_1_69427
addRedisBusinessDataSetComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1831421_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue5("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1831105_1_69427
addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1831106_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1831107_1_69427
addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1831108_1_69427
        // TODO: 2024/6/2
addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(),"yyyy-MM-dd HH:mm:ss"));//CURRENT_DATE
addRedisBusinessDataSetComReqDto.setCustomField8("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1831110_1_69427
addRedisBusinessDataSetComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1831112_1_69427
addRedisBusinessDataSetComReqDto.setCustomField10("isOpenFinance");//CUSTOM_CONVENTION//sourceId:1831114_1_69427
addRedisBusinessDataSetComReqDto.setCustomField11("schemeDataPara");//CUSTOM_CONVENTION//sourceId:1831116_1_69427
addRedisBusinessDataSetComReqDto.setCustomField12("isOkrPlanScene");//CUSTOM_CONVENTION//sourceId:1831118_1_69427
addRedisBusinessDataSetComReqDto.setCustomField13("reportType");//CUSTOM_CONVENTION//sourceId:1831120_1_69427
addRedisBusinessDataSetComReqDto.setCustomField14("cycleMode");//CUSTOM_CONVENTION//sourceId:1831122_1_69427
addRedisBusinessDataSetComReqDto.setCustomField15("fatherCycleType");//CUSTOM_CONVENTION//sourceId:1831124_1_69427
addRedisBusinessDataSetComReqDto.setCustomField16("subcycleType");//CUSTOM_CONVENTION//sourceId:1831126_1_69427
addRedisBusinessDataSetComReqDto.setCustomField17("midCycleType");//CUSTOM_CONVENTION//sourceId:1831128_1_69427
addRedisBusinessDataSetComReqDto.setCustomField18("openMidCycle");//CUSTOM_CONVENTION//sourceId:1831130_1_69427
addRedisBusinessDataSetComReqDto.setCustomField19("lastCycleType");//CUSTOM_CONVENTION//sourceId:1831132_1_69427
addRedisBusinessDataSetComReqDto.setCustomField20("secondLastCycleType");//CUSTOM_CONVENTION//sourceId:1831134_1_69427
addRedisBusinessDataSetComReqDto.setCustomField21("isOpenMidProcess");//CUSTOM_CONVENTION//sourceId:1831136_1_69427
addRedisBusinessDataSetComReqDto.setCustomField22("processMidCycleType");//CUSTOM_CONVENTION//sourceId:1831138_1_69427
addRedisBusinessDataSetComReqDto.setCustomField23("isOpenSubReportLimit");//CUSTOM_CONVENTION//sourceId:1831140_1_69427
addRedisBusinessDataSetComReqDto.setCustomField24("constTaskIsOpenReport");//CUSTOM_CONVENTION//sourceId:1831142_1_69427
addRedisBusinessDataSetComReqDto.setCustomField25("constIsOpenAtuoReport");//CUSTOM_CONVENTION//sourceId:1831144_1_69427
addRedisBusinessDataSetComReqDto.setCustomField26("noPracticalValueObjIsProgReport");//CUSTOM_CONVENTION//sourceId:1831146_1_69427
addRedisBusinessDataSetComReqDto.setCustomField27("actualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1831148_1_69427
addRedisBusinessDataSetComReqDto.setCustomField28("objectiveActualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1831150_1_69427
addRedisBusinessDataSetComReqDto.setCustomField29("actualScoreFormula");//CUSTOM_CONVENTION//sourceId:1831152_1_69427
addRedisBusinessDataSetComReqDto.setCustomField30("subjectiveRatingTotalValue");//CUSTOM_CONVENTION//sourceId:1831154_1_69427
addRedisBusinessDataSetComReqDto.setCustomField31("subjectiveFullMarkUnit");//CUSTOM_CONVENTION//sourceId:1831156_1_69427
addRedisBusinessDataSetComReqDto.setCustomField32("scoreDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831158_1_69427
addRedisBusinessDataSetComReqDto.setCustomField33("degreeDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831160_1_69427
addRedisBusinessDataSetComReqDto.setCustomField34("progressDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831162_1_69427
addRedisBusinessDataSetComReqDto.setCustomField35("subjectiveScorePoint");//CUSTOM_CONVENTION//sourceId:1831164_1_69427
addRedisBusinessDataSetComReqDto.setCustomField36("weightPoint");//CUSTOM_CONVENTION//sourceId:1831166_1_69427
addRedisBusinessDataSetComReqDto.setCustomField37("weightDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831168_1_69427
addRedisBusinessDataSetComReqDto.setCustomField38("increasesDropDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831170_1_69427
addRedisBusinessDataSetComReqDto.setCustomField39("actualValueDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831172_1_69427
addRedisBusinessDataSetComReqDto.setCustomField40("decimalDigitsLastRules");//CUSTOM_CONVENTION//sourceId:1831174_1_69427
addRedisBusinessDataSetComReqDto.setCustomField41("subjectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1831176_1_69427
addRedisBusinessDataSetComReqDto.setCustomField42("objectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1831178_1_69427
addRedisBusinessDataSetComReqDto.setCustomField43("processReportScoreMidWeight");//CUSTOM_CONVENTION//sourceId:1831180_1_69427
addRedisBusinessDataSetComReqDto.setCustomField44("processReportScoreProMidWeight");//CUSTOM_CONVENTION//sourceId:1831182_1_69427
addRedisBusinessDataSetComReqDto.setCustomField45("processReportScoreAvgWeight");//CUSTOM_CONVENTION//sourceId:1831184_1_69427
addRedisBusinessDataSetComReqDto.setCustomField46("reportScoreSubAndObjWeight");//CUSTOM_CONVENTION//sourceId:1831186_1_69427
addRedisBusinessDataSetComReqDto.setCustomField47("actualScoreLocalLevelWeight");//CUSTOM_CONVENTION//sourceId:1831188_1_69427
addRedisBusinessDataSetComReqDto.setCustomField48("actualScoreLowerLevelWeight");//CUSTOM_CONVENTION//sourceId:1831190_1_69427
addRedisBusinessDataSetComReqDto.setCustomField49("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1831192_1_69427
addRedisBusinessDataSetComReqDto.setCustomField50("isOpenBudget");//CUSTOM_CONVENTION//sourceId:1834500_1_69427
addRedisBusinessDataSetComReqDto.setCustomField51("isOpenBudgetReport");//CUSTOM_CONVENTION//sourceId:1834713_1_69427
addRedisBusinessDataSetComReqDto.setCustomField52("useAccountSubjectType");//CUSTOM_CONVENTION//sourceId:1834715_1_69427
addRedisBusinessDataSetComReqDto.setCustomField53("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1834717_1_69427
addRedisBusinessDataSetComReqDto.setCustomField54("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1834719_1_69427
addRedisBusinessDataSetComReqDto.setCustomField55("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1837489_1_69427
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831097_1_69427
    }
if(implementTimeFormatConversionComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue7(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1831109_1_69427
    }
if(implementPreEvaTempConfEntParameterComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue8(implementPreEvaTempConfEntParameterComRespDto.getIsAllowBudgetOverruns());//SimpleFieldAssign//sourceId:1831111_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(implementPreEvaTempConfEntParameterComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1831113_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue10(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1831115_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue11(implementPreEvaTempConfEntParameterComRespDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:1831117_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue12(implementPreEvaTempConfEntParameterComRespDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:1831119_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue13(implementPreEvaTempConfEntParameterComRespDto.getReportType());//SimpleFieldAssign//sourceId:1831121_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue14(implementPreEvaTempConfEntParameterComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1831123_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue15(implementPreEvaTempConfEntParameterComRespDto.getFatherCycleType());//SimpleFieldAssign//sourceId:1831125_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue16(implementPreEvaTempConfEntParameterComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1831127_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue17(implementPreEvaTempConfEntParameterComRespDto.getMidCycleType());//SimpleFieldAssign//sourceId:1831129_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue18(implementPreEvaTempConfEntParameterComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1831131_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue19(implementPreEvaTempConfEntParameterComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1831133_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue20(implementPreEvaTempConfEntParameterComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1831135_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue21(implementPreEvaTempConfEntParameterComRespDto.getIsOpenMidProcess());//SimpleFieldAssign//sourceId:1831137_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue22(implementPreEvaTempConfEntParameterComRespDto.getProcessMidCycleType());//SimpleFieldAssign//sourceId:1831139_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue23(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:1831141_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue24(implementPreEvaTempConfEntParameterComRespDto.getConstTaskIsOpenReport());//SimpleFieldAssign//sourceId:1831143_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue25(implementPreEvaTempConfEntParameterComRespDto.getConstIsOpenAtuoReport());//SimpleFieldAssign//sourceId:1831145_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue26(implementPreEvaTempConfEntParameterComRespDto.getNoPracticalValueObjIsProgReport());//SimpleFieldAssign//sourceId:1831147_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue27(implementPreEvaTempConfEntParameterComRespDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1831149_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue28(implementPreEvaTempConfEntParameterComRespDto.getObjectiveActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1831151_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue29(implementPreEvaTempConfEntParameterComRespDto.getActualScoreFormula());//SimpleFieldAssign//sourceId:1831153_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue30(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue()):"");//SimpleFieldAssign//sourceId:1831155_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue31(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveFullMarkUnit());//SimpleFieldAssign//sourceId:1831157_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue32(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint()):"");//SimpleFieldAssign//sourceId:1831159_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue33(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint()):"");//SimpleFieldAssign//sourceId:1831161_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue34(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint()):"");//SimpleFieldAssign//sourceId:1831163_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue35(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint()):"");//SimpleFieldAssign//sourceId:1831165_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue36(implementPreEvaTempConfEntParameterComRespDto.getWeightPoint());//SimpleFieldAssign//sourceId:1831167_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue37(implementPreEvaTempConfEntParameterComRespDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1831169_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue38(implementPreEvaTempConfEntParameterComRespDto.getIncreasesDropDecimalPoint());//SimpleFieldAssign//sourceId:1831171_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue39(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint()):"");//SimpleFieldAssign//sourceId:1831173_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue40(implementPreEvaTempConfEntParameterComRespDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1831175_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue41(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight()):"");//SimpleFieldAssign//sourceId:1831177_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue42(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight()):"");//SimpleFieldAssign//sourceId:1831179_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue43(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight()):"");//SimpleFieldAssign//sourceId:1831181_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue44(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight()):"");//SimpleFieldAssign//sourceId:1831183_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue45(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight()):"");//SimpleFieldAssign//sourceId:1831185_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue46(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight()):"");//SimpleFieldAssign//sourceId:1831187_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue47(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight()):"");//SimpleFieldAssign//sourceId:1831189_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue48(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight()):"");//SimpleFieldAssign//sourceId:1831191_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue49(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1831193_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue50(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1834501_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue51(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1834714_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue52(implementPreEvaTempConfEntParameterComRespDto.getUseAccountSubjectType());//SimpleFieldAssign//sourceId:1834716_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue53(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834718_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue54(implementPreEvaTempConfEntParameterComRespDto.getIsAllowBudgetOverruns());//SimpleFieldAssign//sourceId:1834720_1_69427
addRedisBusinessDataSetComReqDto.setCustomFieldValue55(implementPreEvaTempConfEntParameterComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837490_1_69427
    }

    /*D2增规划目标计算MQ遥控器Redis（公共）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段17不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField18(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段18不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue18(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值18不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField19(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段19不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue19(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值19不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField20(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段20不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField21(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段21不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue21(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值21不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField22(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段22不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField23(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段23不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue23(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值23不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField24(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段24不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue24(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值24不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField25(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段25不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue25(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值25不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField26(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段26不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue26(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值26不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField27(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段27不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue27(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值27不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField28(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段28不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue28(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值28不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField29(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段29不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField30(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段30不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField31(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段31不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField32(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段32不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField33(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段33不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField34(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段34不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField35(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段35不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField36(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段36不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue36(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值36不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField37(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段37不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue37(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值37不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField38(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段38不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue38(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值38不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField39(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段39不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue39(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值39不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField40(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段40不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue40(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值40不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField41(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段41不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue41(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值41不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField42(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段42不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue42(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值42不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField43(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段43不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue43(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值43不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField44(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段44不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue44(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值44不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField45(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段45不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue45(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值45不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField46(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段46不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue46(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值46不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField47(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段47不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue47(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值47不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField48(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段48不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue48(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值48不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField49(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段49不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue49(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值49不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField50(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段50不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue50(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值50不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField51(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段51不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue51(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值51不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField52(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段52不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue52(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值52不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField53(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段53不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue53(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值53不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField54(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段54不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue54(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值54不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField55(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段55不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue55(),"D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值55不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }
      }
AddPlanTargetCalcMqRemoteControllerComRespDto retData = new AddPlanTargetCalcMqRemoteControllerComRespDto();





return retData;
  }
/**
   * D2新增规划财务MQ遥控器(公共)[9691]
   * gen by moon at 7/2/2024, 3:20:02 AM
   */
  @Trace(operationName = "D2新增规划财务MQ遥控器(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddFinancialPlannMqRemoteControllerComRespDto addFinancialPlannMqRemoteControllerCom(AddFinancialPlannMqRemoteControllerComReqDto reqDto){


      //virtualUsage M2接收入参字段  69468
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1834892_1_69468
if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1833017_1_69468
receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834530_1_69468
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834531_1_69468
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2新增规划财务MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationSubjectId(),"D2新增规划财务MQ遥控器(公共)-M2接收入参字段-冗余评价主题ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D2新增规划财务MQ遥控器(公共)-M2接收入参字段-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getOperateTime(),"D2新增规划财务MQ遥控器(公共)-M2接收入参字段-操作时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



//virtualUsage D2系统当前操作时间  69872
      ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(receptionServiceRes!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(receptionServiceRes.getOperateTime()!=null?String.valueOf(receptionServiceRes.getOperateTime()):"");//SimpleFieldAssign//sourceId:1861435_1_69872
    }

    /*D2系统当前操作时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D2新增规划财务MQ遥控器(公共)-D2系统当前操作时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2查询规划财务MQ遥控器Redis（用于判断是否已存在）  69489
      QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
    QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto=new QuerySingleRemoteControllerRedisDetailComReqDto();
querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839416_1_69489
querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839415_1_69489
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839417_1_69489
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861433_1_69489
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue2("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1861434_1_69489
if(reqDto!=null){
      querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839418_1_69489
    }

    /*D2查询规划财务MQ遥控器Redis（用于判断是否已存在）[9708]   */
    Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空",false);
    Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField2(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段2不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue2(),"D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值2不能为空",false);
      querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((querySingleRemoteControllerRedisDetailComRespDto!= null&& querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null )) {
        //if(D2查询规划财务MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69450

PreparationStatisticalFundSourcesAccountConfParametersComRespDto preparationStatisticalFundSourcesAccountConfParametersComRespDto = null;
    PreparationStatisticalFundSourcesAccountConfParametersComReqDto preparationStatisticalFundSourcesAccountConfParametersComReqDto=new PreparationStatisticalFundSourcesAccountConfParametersComReqDto();
  if(reqDto!=null){
      preparationStatisticalFundSourcesAccountConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834504_1_69458
preparationStatisticalFundSourcesAccountConfParametersComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834505_1_69458
preparationStatisticalFundSourcesAccountConfParametersComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834506_1_69458
    }

    /*D2准备统计资金来源及账户配置参数(公共)[9701]   */
    Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getEvaluationTemplateId(),"D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getEvaluationSubjectId(),"D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-冗余评价主题ID不能为空",false);
Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getSpaceId(),"D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-创建于空间ID不能为空",false);
      preparationStatisticalFundSourcesAccountConfParametersComRespDto = preparationStatisticalFundSourcesAccountConfParametersCom(preparationStatisticalFundSourcesAccountConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;



AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(implementTimeFormatConversionComRespDto !=null&&preparationStatisticalFundSourcesAccountConfParametersComRespDto !=null){
          AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1833020_1_69451
addRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1833019_1_69451
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1833021_1_69451
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1833022_1_69451
addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1833023_1_69451
addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1833025_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1833026_1_69451
addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1833027_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1833028_1_69451
addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834514_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1834515_1_69451
addRedisBusinessDataSetComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1834516_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue5("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1834517_1_69451
addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1834518_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1834519_1_69451
addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1834520_1_69451
addRedisBusinessDataSetComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1834522_1_69451
addRedisBusinessDataSetComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1834524_1_69451
addRedisBusinessDataSetComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:1915675_1_69451
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1833024_1_69451
    }
if(implementTimeFormatConversionComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue7(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1834521_1_69451
    }
if(preparationStatisticalFundSourcesAccountConfParametersComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834523_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getFundUnit());//SimpleFieldAssign//sourceId:1834525_1_69451
addRedisBusinessDataSetComReqDto.setCustomFieldValue10(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1915676_1_69451
    }

    /*D2增规划财务MQ遥控器Redis[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(),"D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值10不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }
      }
AddFinancialPlannMqRemoteControllerComRespDto retData = new AddFinancialPlannMqRemoteControllerComRespDto();





return retData;
  }
/**
   * D2遥控器MQ排队(修改单条redis)[9693]
   * gen by moon at 12/3/2024, 10:54:03 AM
   */
  @Trace(operationName = "D2遥控器MQ排队(修改单条redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueCom(UpdateRemoteControllerMqQueueComReqDto reqDto){


      ImplementTenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage D2查评价模板的排队最小值与排队最大值  69429
      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831675_1_69429
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831677_1_69429
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831680_1_69429
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831824_1_69429
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831674_1_69429
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831678_1_69429
    }

    /*D2查评价模板的排队最小值与排队最大值[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-自定义字段3不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage M2接收排队最小值排队最大值  69566
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    if(queryRefRedisBusinessDataSetDetailComRespDto !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto!=null){
      receptionServiceReq.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()!=null?Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()):null);//SimpleFieldAssign//sourceId:1847354_1_69566
receptionServiceReq.setQueueMaximum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()!=null?Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()):null);//SimpleFieldAssign//sourceId:1847355_1_69566
    }

    /*M2接收排队最小值排队最大值[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getQueueMinimum(),"D2遥控器MQ排队(修改单条redis)-M2接收排队最小值排队最大值-排队最小值不能为空",false);
Assert.isNull(receptionServiceReq.getQueueMaximum(),"D2遥控器MQ排队(修改单条redis)-M2接收排队最小值排队最大值-排队最大值不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



           }
if((receptionServiceRes!= null&& receptionServiceRes.getQueueMinimum() != null &&receptionServiceRes!= null&& receptionServiceRes.getQueueMaximum() != null )) {
        //if((M2接收原始排队最小值排队最大值.排队最小值 值不等于空  and M2接收原始排队最小值排队最大值.排队最大值 值不等于空 ))  69430

ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto=new ImplementNumericalContrastMagnitudeComReqDto();
  if(receptionServiceRes!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara1(receptionServiceRes.getQueueMinimum()!=null?Double.valueOf(receptionServiceRes.getQueueMinimum()):null);//SimpleFieldAssign//sourceId:1832076_1_69436
implementNumericalContrastMagnitudeComReqDto.setCalcPara2(receptionServiceRes.getQueueMaximum()!=null?Double.valueOf(receptionServiceRes.getQueueMaximum()):null);//SimpleFieldAssign//sourceId:1832077_1_69436
    }

    /*D2排队最小值与排队最大值比较[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(),"D2遥控器MQ排队(修改单条redis)-D2排队最小值与排队最大值比较-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(),"D2遥控器MQ排队(修改单条redis)-D2排队最小值与排队最大值比较-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto = interfaceModeService.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto)/*vcase invoke isSameApp*/;



if((receptionServiceRes!= null&& receptionServiceRes.getQueueMinimum() == 0L&&receptionServiceRes!= null&& receptionServiceRes.getQueueMaximum() == 0L)) {
        //if((M2接收原始排队最小值排队最大值.排队最小值 等于 0 and M2接收原始排队最小值排队最大值.排队最大值 等于 0))  69437

CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto = null;
          CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto=new CalculateAdditionOfTwoNumsComReqDto();
  calculateAdditionOfTwoNumsComReqDto.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834732_1_69464
if(receptionServiceRes!=null){
      calculateAdditionOfTwoNumsComReqDto.setCalcPara1(receptionServiceRes.getQueueMinimum()!=null?Double.valueOf(receptionServiceRes.getQueueMinimum()):null);//SimpleFieldAssign//sourceId:1834731_1_69464
    }

    /*D2排队最小值+1[8137]   */
    Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara1(),"D2遥控器MQ排队(修改单条redis)-D2排队最小值+1-计算入参1不能为空",false);
Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara2(),"D2遥控器MQ排队(修改单条redis)-D2排队最小值+1-计算入参2不能为空",false);
      calculateAdditionOfTwoNumsComRespDto = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto)/*vcase invoke isSameApp*/;



CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto_2 = null;
          CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto_1=new CalculateAdditionOfTwoNumsComReqDto();
  calculateAdditionOfTwoNumsComReqDto_1.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834735_1_69465
if(receptionServiceRes!=null){
      calculateAdditionOfTwoNumsComReqDto_1.setCalcPara1(receptionServiceRes.getQueueMaximum()!=null?Double.valueOf(receptionServiceRes.getQueueMaximum()):null);//SimpleFieldAssign//sourceId:1834734_1_69465
    }

    /*D2排队最大值+1[8137]   */
    Assert.isNull(calculateAdditionOfTwoNumsComReqDto_1.getCalcPara1(),"D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参1不能为空",false);
Assert.isNull(calculateAdditionOfTwoNumsComReqDto_1.getCalcPara2(),"D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参2不能为空",false);
      calculateAdditionOfTwoNumsComRespDto_2 = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto_1)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(calculateAdditionOfTwoNumsComRespDto !=null&&calculateAdditionOfTwoNumsComRespDto_2 !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_1=new ImplementTenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69717
receptionServiceReq_1.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69717
    }
if(calculateAdditionOfTwoNumsComRespDto!=null){
    // TODO: 2024/6/8  
      receptionServiceReq_1.setQueueMinimum(calculateAdditionOfTwoNumsComRespDto.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832222_1_69717
    }
if(calculateAdditionOfTwoNumsComRespDto_2!=null){
    // TODO: 2024/6/8  
      receptionServiceReq_1.setQueueMaximum(calculateAdditionOfTwoNumsComRespDto_2.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832223_1_69717
    }

    /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getQueueMinimumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_1.getQueueMinimum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_1.getQueueMaximumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空",false);
Assert.isNull(receptionServiceReq_1.getQueueMaximum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
          UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69441
updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831811_1_69441
updateRedisBusinessDataSetComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69441
updateRedisBusinessDataSetComReqDto.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69441
updateRedisBusinessDataSetComReqDto.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69441
updateRedisBusinessDataSetComReqDto.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69441
updateRedisBusinessDataSetComReqDto.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69441
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69441
updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69441
    }
if(receptionServiceRes_2!=null){
      updateRedisBusinessDataSetComReqDto.setCustomFieldValue1(receptionServiceRes_2.getQueueMinimum()!=null?String.valueOf(receptionServiceRes_2.getQueueMinimum()):"");//SimpleFieldAssign//sourceId:1831815_1_69441
updateRedisBusinessDataSetComReqDto.setCustomFieldValue2(receptionServiceRes_2.getQueueMaximum()!=null?String.valueOf(receptionServiceRes_2.getQueueMaximum()):"");//SimpleFieldAssign//sourceId:1831817_1_69441
    }

    /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空",false);
      updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



      }
else if((implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("LATER"))){
       //elseif(D2排队最小值与排队最大值比较.数值比较结果 等于 之后（大于）)  69438

//ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq_2=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq_2.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1832080_1_69443
if(reqDto!=null){
      receptionServiceReq_2.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831819_1_69443
receptionServiceReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831818_1_69443
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getBusinessDataObject(),"D2遥控器MQ排队(修改单条redis)-M2接收入参字段-业务数据对象不能为空",false);
Assert.isNull(receptionServiceReq_2.getEvaluationTemplateId(),"D2遥控器MQ排队(修改单条redis)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq_2.getComNumField(),"D2遥控器MQ排队(修改单条redis)-M2接收入参字段-通用数值字段（整数型）不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_2);



UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto_1 = null;
    UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto_1=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69442
updateRedisBusinessDataSetComReqDto_1.setIsDataList("TRUE");//sourceId:1831811_1_69442
updateRedisBusinessDataSetComReqDto_1.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69442
updateRedisBusinessDataSetComReqDto_1.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69442
updateRedisBusinessDataSetComReqDto_1.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69442
updateRedisBusinessDataSetComReqDto_1.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69442
updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69442
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto_1.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69442
updateRedisBusinessDataSetComReqDto_1.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69442
    }
if(receptionServiceRes_4!=null){
      updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue1(receptionServiceRes_4.getComNumField()!=null?String.valueOf(receptionServiceRes_4.getComNumField()):"");//SimpleFieldAssign//sourceId:1831815_1_69442
updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue2(receptionServiceRes_4.getComNumField()!=null?String.valueOf(receptionServiceRes_4.getComNumField()):"");//SimpleFieldAssign//sourceId:1831817_1_69442
    }

    /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRedisDataObjectCatalogue(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getBusinessDataObject(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getIsDataList(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRefCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRefCustomFieldValue1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomFieldValue2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomFieldValue3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空",false);
      updateRedisBusinessDataSetComRespDto_1 = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto_1)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq_3=new ImplementTenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69445
receptionServiceReq_3.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69445
    }
if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setQueueMinimum(receptionServiceRes_4.getComNumField());//SimpleFieldAssign//sourceId:1832222_1_69445
receptionServiceReq_3.setQueueMaximum(receptionServiceRes_4.getComNumField());//SimpleFieldAssign//sourceId:1832223_1_69445
    }

    /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getQueueMinimumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_3.getQueueMinimum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_3.getQueueMaximumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空",false);
Assert.isNull(receptionServiceReq_3.getQueueMaximum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空",false);
      receptionServiceRes_6 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
           }
else if((receptionServiceRes!= null&& receptionServiceRes.getQueueMinimum() > 0L&&receptionServiceRes!= null&& receptionServiceRes.getQueueMaximum() > 0L)&&(implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("BEFORE")||implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("PRESENT"))){
       //elseif((M2接收原始排队最小值排队最大值.排队最小值 大于 0 and M2接收原始排队最小值排队最大值.排队最大值 大于 0) and (D2排队最小值与排队最大值比较.数值比较结果 等于 之前（小于） or D2排队最小值与排队最大值比较.数值比较结果 等于 当前（等于）))  69460

CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto_4 = null;
          CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto_2=new CalculateAdditionOfTwoNumsComReqDto();
  calculateAdditionOfTwoNumsComReqDto_2.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834735_1_69466
if(receptionServiceRes!=null){
      calculateAdditionOfTwoNumsComReqDto_2.setCalcPara1(receptionServiceRes.getQueueMaximum()!=null?Double.valueOf(receptionServiceRes.getQueueMaximum()):null);//SimpleFieldAssign//sourceId:1834734_1_69466
    }

    /*D2排队最大值+1[8137]   */
    Assert.isNull(calculateAdditionOfTwoNumsComReqDto_2.getCalcPara1(),"D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参1不能为空",false);
Assert.isNull(calculateAdditionOfTwoNumsComReqDto_2.getCalcPara2(),"D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参2不能为空",false);
      calculateAdditionOfTwoNumsComRespDto_4 = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto_2)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_7 = null;
    if(calculateAdditionOfTwoNumsComRespDto_4 !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_4=new ImplementTenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69718
receptionServiceReq_4.setQueueMinimum(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832222_1_69718
receptionServiceReq_4.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69718
    }
    if(calculateAdditionOfTwoNumsComRespDto_4 !=null){
        // TODO: 2024/6/8  
      receptionServiceReq_4.setQueueMaximum(calculateAdditionOfTwoNumsComRespDto_4.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832223_1_69718
    }

    /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getQueueMinimumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_4.getQueueMinimum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空",false);
Assert.isNull(receptionServiceReq_4.getQueueMaximumOri(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空",false);
Assert.isNull(receptionServiceReq_4.getQueueMaximum(),"D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空",false);
      receptionServiceRes_7 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_7;
           }
UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto_2 = null;
          UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto_2=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto_2.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69462
updateRedisBusinessDataSetComReqDto_2.setIsDataList("TRUE");//sourceId:1831811_1_69462
updateRedisBusinessDataSetComReqDto_2.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69462
updateRedisBusinessDataSetComReqDto_2.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69462
updateRedisBusinessDataSetComReqDto_2.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69462
updateRedisBusinessDataSetComReqDto_2.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69462
updateRedisBusinessDataSetComReqDto_2.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69462
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto_2.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69462
updateRedisBusinessDataSetComReqDto_2.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69462
    }
if(receptionServiceRes_7!=null){
      updateRedisBusinessDataSetComReqDto_2.setCustomFieldValue2(receptionServiceRes_7.getQueueMaximum()!=null?String.valueOf(receptionServiceRes_7.getQueueMaximum()):"");//SimpleFieldAssign//sourceId:1831817_1_69462
    }

    /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRedisDataObjectCatalogue(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getBusinessDataObject(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getIsDataList(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRefCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRefCustomFieldValue1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField1(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomFieldValue2(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomFieldValue3(),"D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空",false);
      updateRedisBusinessDataSetComRespDto_2 = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto_2)/*vcase invoke isSameApp*/;



    }
      }
else{
       //else  69433

//异常结束 69434
      throw new BizException("C221000449","对不起，MQ的遥控器redis未初始化~",false);
    }
UpdateRemoteControllerMqQueueComRespDto retData = new UpdateRemoteControllerMqQueueComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setQueueMinimumOri(receptionServiceRes_3.getQueueMinimumOri()!=null?receptionServiceRes_3.getQueueMinimumOri().longValue():null);//SimpleFieldAssign//sourceId:1832230_1
retData.setQueueMinimum(receptionServiceRes_3.getQueueMinimum()!=null?receptionServiceRes_3.getQueueMinimum().longValue():null);//SimpleFieldAssign//sourceId:1832231_1
retData.setQueueMaximumOri(receptionServiceRes_3.getQueueMaximumOri()!=null?receptionServiceRes_3.getQueueMaximumOri().longValue():null);//SimpleFieldAssign//sourceId:1832232_1
retData.setQueueMaximum(receptionServiceRes_3.getQueueMaximum()!=null?receptionServiceRes_3.getQueueMaximum().longValue():null);//SimpleFieldAssign//sourceId:1832233_1
    }




return retData;
  }
/**
   * D2规划目标计算MQ排队(新增单条redis)[9694]
   * gen by moon at 6/8/2024, 8:04:35 PM
   */
  @Trace(operationName = "D2规划目标计算MQ排队(新增单条redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanTargetCalcMqQueueRedisComRespDto addPlanTargetCalcMqQueueRedisCom(AddPlanTargetCalcMqQueueRedisComReqDto reqDto){


      //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832214_1
receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855399_1
receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855400_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(),"D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(),"D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-更新周期结束时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:1855405_1
    }

    /*D2更新周期开始时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D2规划目标计算MQ排队(新增单条redis)-D2更新周期开始时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:1855407_1
    }

    /*D2更新周期结束时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(),"D2规划目标计算MQ排队(新增单条redis)-D2更新周期结束时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1)/*vcase invoke isSameApp*/;




//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
     AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(implementTimeFormatConversionComRespDto !=null){
    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831938_1
  addRedisBusinessDataSetComReqDto.setBusinessDataObject("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:1831937_1
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1831939_1
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831940_1
addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1831941_1
addRedisBusinessDataSetComReqDto.setCustomField2("targetAttributionCycleId");//CUSTOM_CONVENTION//sourceId:1831943_1
addRedisBusinessDataSetComReqDto.setCustomField3("isLastCycle");//CUSTOM_CONVENTION//sourceId:1832386_1
addRedisBusinessDataSetComReqDto.setCustomField4("spaceId");//CUSTOM_CONVENTION//sourceId:1849443_1
addRedisBusinessDataSetComReqDto.setCustomField5("appId");//CUSTOM_CONVENTION//sourceId:1849445_1
addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1849447_1
addRedisBusinessDataSetComReqDto.setCustomField7("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1852045_1
addRedisBusinessDataSetComReqDto.setCustomField8("updateCycleId");//CUSTOM_CONVENTION//sourceId:1852047_1
addRedisBusinessDataSetComReqDto.setCustomField9("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1852049_1
addRedisBusinessDataSetComReqDto.setCustomField10("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1852051_1
addRedisBusinessDataSetComReqDto.setCustomField11("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1852053_1
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831947_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1831942_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1831944_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1832387_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1849444_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:1849446_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1849448_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1852046_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1852048_1

addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1852054_1
    }
if(implementTimeFormatConversionComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue9(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1852050_1
    }
if(implementTimeFormatConversionComRespDto_2!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue10(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1852052_1
    }

    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
    Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(),"D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }

AddPlanTargetCalcMqQueueRedisComRespDto retData = new AddPlanTargetCalcMqQueueRedisComRespDto();





return retData;
  }
/**
   * D2执行规划目标计算MQ排队(公共)[9696]
   * gen by moon at 6/8/2024, 3:19:51 AM
   */
  @Trace(operationName = "D2执行规划目标计算MQ排队(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementPlanTargetCalcMqQueueComRespDto implementPlanTargetCalcMqQueueCom(ImplementPlanTargetCalcMqQueueComReqDto reqDto){


      //virtualUsage D2执行并发行为主题锁(悬停等待)-上锁  69456
      ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto = null;
    ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto=new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
  implementConcurrencyBehaviorThemeLockWaitComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1834296_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1834297_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1834299_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitingTime("10");//CUSTOM_CONVENTION//sourceId:1834300_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitTimeUnitType("MINUTES");//sourceId:1834301_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1834302_1_69456
implementConcurrencyBehaviorThemeLockWaitComReqDto.setTimeUnitType("MINUTES");//sourceId:1834303_1_69456
if(reqDto!=null){
      implementConcurrencyBehaviorThemeLockWaitComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834298_1_69456
    }

    /*D2执行并发行为主题锁(悬停等待)-上锁[9699]   */
    Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getRedisDataObjectCatalogue(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getBusinessDataObject(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-业务数据对象不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDataObjectBatchCode(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-数据对象批次标识不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getPreventConcurrentLockingUnlocking(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDuration(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-锁定时长不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getTimeUnitType(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-时间单位类型不能为空",false);
      implementConcurrencyBehaviorThemeLockWaitComRespDto = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto)/*vcase invoke isSameApp*/;



if((implementConcurrencyBehaviorThemeLockWaitComRespDto!= null&&  implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行并发行为主题锁(悬停等待)-上锁.防并发上锁情况 等于 空上锁成功)  69545

      UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueComRespDto = null;
    UpdateRemoteControllerMqQueueComReqDto updateRemoteControllerMqQueueComReqDto=new UpdateRemoteControllerMqQueueComReqDto();
  updateRemoteControllerMqQueueComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1832234_1_69546
if(reqDto!=null){
      updateRemoteControllerMqQueueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832235_1_69546
    }

    /*D2遥控器MQ排队(修改单条redis)[9693]   */
    Assert.isNull(updateRemoteControllerMqQueueComReqDto.getBusinessDataObject(),"D2执行规划目标计算MQ排队(公共)-D2遥控器MQ排队(修改单条redis)-业务数据对象不能为空",false);
Assert.isNull(updateRemoteControllerMqQueueComReqDto.getEvaluationTemplateId(),"D2执行规划目标计算MQ排队(公共)-D2遥控器MQ排队(修改单条redis)-冗余评价模板ID不能为空",false);
      updateRemoteControllerMqQueueComRespDto = updateRemoteControllerMqQueueCom(updateRemoteControllerMqQueueComReqDto)/*vcase invoke 同服务,同domain*/;



if((updateRemoteControllerMqQueueComRespDto!= null&& updateRemoteControllerMqQueueComRespDto.getQueueMinimum() != null &&updateRemoteControllerMqQueueComRespDto!= null&& updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null )) {
        //if((D2遥控器MQ排队(修改单条redis).排队最小值 值不等于空  and D2遥控器MQ排队(修改单条redis).排队最大值 值不等于空 ))  69547

AddPlanTargetCalcMqQueueRedisComRespDto addPlanTargetCalcMqQueueRedisComRespDto = null;
    if(updateRemoteControllerMqQueueComRespDto !=null){
          AddPlanTargetCalcMqQueueRedisComReqDto addPlanTargetCalcMqQueueRedisComReqDto=new AddPlanTargetCalcMqQueueRedisComReqDto();
  addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue4(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1849452_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue5(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1849453_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1852137_1_69548
  if(updateRemoteControllerMqQueueComRespDto!=null){
      addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue1(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()!=null?String.valueOf(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()):"");//SimpleFieldAssign//sourceId:1832389_1_69548
    }
if(reqDto!=null){
      addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue2(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1832390_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue7(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1852062_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue8(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1852063_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855403_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855404_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue11(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1852066_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue3(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1832391_1_69548
addPlanTargetCalcMqQueueRedisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832242_1_69548
    }

    /*D2规划目标计算MQ排队(新增单条redis)[9694]   */
    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue1(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-排队值不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue2(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-目标归属周期ID不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue8(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期ID不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getUpdateCycleStartTime(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期开始时间不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getUpdateCycleEndTime(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期结束时间不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue11(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期类型标识不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue3(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期是否末级周期不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getEvaluationTemplateId(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-冗余评价模板ID不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue4(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-创建于空间ID不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue5(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-创建于联盟应用ID不能为空",false);
Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue6(),"D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-操作人就职记录ID不能为空",false);
      addPlanTargetCalcMqQueueRedisComRespDto = addPlanTargetCalcMqQueueRedisCom(addPlanTargetCalcMqQueueRedisComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = null;
    ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto_1=new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
  implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1834304_1_69549
implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1834305_1_69549
implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1834307_1_69549
if(reqDto!=null){
      implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834306_1_69549
    }

    /*D2执行并发行为主题锁(悬停等待)-解锁[9699]   */
    Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getRedisDataObjectCatalogue(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getBusinessDataObject(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-业务数据对象不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getDataObjectBatchCode(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-数据对象批次标识不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getPreventConcurrentLockingUnlocking(),"D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-防并发上锁or解锁不能为空",false);
      implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto_1)/*vcase invoke isSameApp*/;



      }
ImplementPlanTargetCalcMqQueueComRespDto retData = new ImplementPlanTargetCalcMqQueueComRespDto();





return retData;
  }
/**
   * D2准备统计资金来源及账户配置参数(公共)[9701]
   * gen by moon at 6/1/2024, 12:55:55 AM
   */
  @Trace(operationName = "D2准备统计资金来源及账户配置参数(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationStatisticalFundSourcesAccountConfParametersComRespDto preparationStatisticalFundSourcesAccountConfParametersCom(PreparationStatisticalFundSourcesAccountConfParametersComReqDto reqDto){


      ImplementTenReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834098_1
receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834182_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834258_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationSubjectId(),"D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-冗余评价主题ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:1834247_1
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_FINANCE");//CUSTOM_CONVENTION//sourceId:1834248_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1834249_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834246_1
    }

    /*D2查空间开启财务管理模式配置参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:1834251_1
queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1834252_1
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1834253_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834250_1
    }

    /*D2查评价模板周期模式配置参数答案（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1)/*vcase invoke isSameApp*/;




//步骤3: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjType("EVA_THEME");//sourceId:1834288_1
queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("IS_OPEN_BUDGET");//CUSTOM_CONVENTION//sourceId:1834289_1
queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:1834290_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834287_1
    }

    /*D2查评价主题是否开启预算配置参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_4 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2)/*vcase invoke isSameApp*/;




//步骤4: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_6 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjType("EVA_THEME");//sourceId:1834293_1
queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("BUDGET_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1834294_1
queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:1834295_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834292_1
    }

    /*D2-3查评价主题配置预算层级参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_6 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3)/*vcase invoke isSameApp*/;




//步骤5: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_8 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_4=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_4.setResultAspObjType("EVA_THEME");//sourceId:1834314_1
queryConfItemMatchAnswerDetailComReqDto_4.setConfItemCode("BUDGET_REPORT_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1834315_1
queryConfItemMatchAnswerDetailComReqDto_4.setIsPlatData("FALSE");//sourceId:1834316_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_4.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834313_1
    }

    /*D2查评价主题配置费用汇报层级配置参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_8 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_4)/*vcase invoke isSameApp*/;




//步骤6: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_10 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_5=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjType("EVA_THEME");//sourceId:1834320_1
queryConfItemMatchAnswerDetailComReqDto_5.setConfItemCode("IS_OPEN_FUNDS_ARRIVAL");//CUSTOM_CONVENTION//sourceId:1834321_1
queryConfItemMatchAnswerDetailComReqDto_5.setIsPlatData("FALSE");//sourceId:1834322_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834319_1
    }

    /*D2查评价主题配置是否开启资金到账配置参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_10 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_5)/*vcase invoke isSameApp*/;




//步骤7: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_12 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_6=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjType("EVA_THEME");//sourceId:1834325_1
queryConfItemMatchAnswerDetailComReqDto_6.setConfItemCode("CASH_ACCOUNT_UNIT");//CUSTOM_CONVENTION//sourceId:1834326_1
queryConfItemMatchAnswerDetailComReqDto_6.setIsPlatData("FALSE");//sourceId:1834327_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834324_1
    }

    /*D2查询评价主题配置资金单位参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getResultAspObjId(),"D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getResultAspObjType(),"D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getConfItemCode(),"D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getIsPlatData(),"D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_12 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_6)/*vcase invoke isSameApp*/;




//步骤8: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
    if(queryConfItemMatchAnswerDetailComRespDto_2 !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_1=new ImplementTenReceivingFieldReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      receptionServiceReq_1.setCycleMode(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1834481_1
    }
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      receptionServiceReq_1.setIsOpenFinance(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1834477_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_4!=null){
      receptionServiceReq_1.setIsOpenBudget(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1834483_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_6!=null){
      receptionServiceReq_1.setBudgetLevel(queryConfItemMatchAnswerDetailComRespDto_6.getEndValue());//SimpleFieldAssign//sourceId:1834476_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_8!=null){
      receptionServiceReq_1.setCostReportLevel(queryConfItemMatchAnswerDetailComRespDto_8.getEndValue());//SimpleFieldAssign//sourceId:1834478_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_10!=null){
      receptionServiceReq_1.setIsOpenFundsArrival(queryConfItemMatchAnswerDetailComRespDto_10.getEndValue());//SimpleFieldAssign//sourceId:1834479_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_12!=null){
      receptionServiceReq_1.setFundUnit(queryConfItemMatchAnswerDetailComRespDto_12.getConfOptionName());//SimpleFieldAssign//sourceId:1834480_1
    }

    /*M2接收预算配置相关参数[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleMode(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-周期模式不能为空",false);
Assert.isNull(receptionServiceReq_1.getIsOpenFinance(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-开启财务管理模式不能为空",false);
Assert.isNull(receptionServiceReq_1.getIsOpenBudget(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-是否启用预算不能为空",false);
Assert.isNull(receptionServiceReq_1.getBudgetLevel(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-预算层级不能为空",false);
Assert.isNull(receptionServiceReq_1.getCostReportLevel(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-费用汇报层级不能为空",false);
Assert.isNull(receptionServiceReq_1.getIsOpenFundsArrival(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-是否开启资金到账不能为空",false);
Assert.isNull(receptionServiceReq_1.getFundUnit(),"D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-资金单位不能为空",false);
      receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

PreparationStatisticalFundSourcesAccountConfParametersComRespDto retData = new PreparationStatisticalFundSourcesAccountConfParametersComRespDto();
  if(receptionServiceRes_2!=null){
      retData.setIsOpenBudget(receptionServiceRes_2.getIsOpenBudget());//SimpleFieldAssign//sourceId:1834495_1
retData.setBudgetLevel(receptionServiceRes_2.getBudgetLevel());//SimpleFieldAssign//sourceId:1834496_1
retData.setCostReportLevel(receptionServiceRes_2.getCostReportLevel());//SimpleFieldAssign//sourceId:1834497_1
retData.setIsOpenFundsArrival(receptionServiceRes_2.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834498_1
retData.setFundUnit(receptionServiceRes_2.getFundUnit());//SimpleFieldAssign//sourceId:1834499_1
retData.setIsOpenFinance(receptionServiceRes_2.getIsOpenFinance());//SimpleFieldAssign//sourceId:1834494_1
retData.setCycleMode(receptionServiceRes_2.getCycleMode());//SimpleFieldAssign//sourceId:1834493_1
    }




return retData;
  }
/**
   * D2新增OKR目标计算MQ遥控器(公共)[9697]
   * gen by moon at 6/2/2024, 1:02:14 AM
   */
  @Trace(operationName = "D2新增OKR目标计算MQ遥控器(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddOkrTargetCalcMqRemoteControllerComRespDto addOkrTargetCalcMqRemoteControllerCom(AddOkrTargetCalcMqRemoteControllerComReqDto reqDto){


      //virtualUsage M2接收入参字段  69469
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1835318_1_69469
if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835316_1_69469
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2新增OKR目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getOperateTime(),"D2新增OKR目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



//virtualUsage D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）  69492
      QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
    QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto=new QuerySingleRemoteControllerRedisDetailComReqDto();
  querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("OKR_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1839430_1_69492
querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839431_1_69492
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839432_1_69492
if(reqDto!=null){
      querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839433_1_69492
    }

    /*D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）[9708]   */
    Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(),"D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(),"D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(),"D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(),"D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空",false);
      querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((querySingleRemoteControllerRedisDetailComRespDto!= null&& querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null )) {
        //if(D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69471

PreparationOkrTargetCalcConfParametersComRespDto preparationOkrTargetCalcConfParametersComRespDto = null;
    PreparationOkrTargetCalcConfParametersComReqDto preparationOkrTargetCalcConfParametersComReqDto=new PreparationOkrTargetCalcConfParametersComReqDto();
  if(reqDto!=null){
      preparationOkrTargetCalcConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835076_1_69472
    }

    /*D2准备OKR目标计算配置参数(公共)[9703]   */
    Assert.isNull(preparationOkrTargetCalcConfParametersComReqDto.getEvaluationTemplateId(),"D2新增OKR目标计算MQ遥控器(公共)-D2准备OKR目标计算配置参数(公共)-冗余评价模板ID不能为空",false);
      preparationOkrTargetCalcConfParametersComRespDto = preparationOkrTargetCalcConfParametersCom(preparationOkrTargetCalcConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;



AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(preparationOkrTargetCalcConfParametersComRespDto !=null){
          AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1835480_1_69473
addRedisBusinessDataSetComReqDto.setBusinessDataObject("OKR_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1835479_1_69473
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1835482_1_69473
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1835481_1_69473
addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1835483_1_69473
addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1835485_1_69473
addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1835486_1_69473
addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1835487_1_69473
addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1835488_1_69473
addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1835489_1_69473
addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1835490_1_69473
addRedisBusinessDataSetComReqDto.setCustomField5("MQ_REMOTE_CONTROLLER_NAME");//CUSTOM_CONVENTION//sourceId:1835491_1_69473
addRedisBusinessDataSetComReqDto.setCustomFieldValue5("OKR_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1835492_1_69473
addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1835493_1_69473
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1835494_1_69473
addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1835495_1_69473
addRedisBusinessDataSetComReqDto.setCustomField8("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1835497_1_69473
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835484_1_69473
    }
if(receptionServiceRes!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(),"yyyy-MM-dd HH:mm:ss"));//SimpleFieldAssign//sourceId:1835496_1_69473
    }
if(preparationOkrTargetCalcConfParametersComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationOkrTargetCalcConfParametersComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1835498_1_69473
    }

    /*D2增OKR目标计算MQ遥控器Redis[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值8不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }
      }
AddOkrTargetCalcMqRemoteControllerComRespDto retData = new AddOkrTargetCalcMqRemoteControllerComRespDto();





return retData;
  }
/**
   * D2新增绩效目标计算MQ遥控器(公共)[9698]
   * gen by moon at 6/2/2024, 1:02:16 AM
   */
  @Trace(operationName = "D2新增绩效目标计算MQ遥控器(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddKpiTargetCalcMqRemoteControllerComRespDto addKpiTargetCalcMqRemoteControllerCom(AddKpiTargetCalcMqRemoteControllerComReqDto reqDto){


      //virtualUsage M2接收入参字段  69481
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1836480_1_69481
if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1836479_1_69481
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2新增绩效目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getOperateTime(),"D2新增绩效目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



//virtualUsage D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）  69491
      QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
    QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto=new QuerySingleRemoteControllerRedisDetailComReqDto();
  querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839426_1_69491
querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("KPI_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1839425_1_69491
querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839427_1_69491
if(reqDto!=null){
      querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839428_1_69491
    }

    /*D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）[9708]   */
    Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(),"D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(),"D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(),"D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空",false);
Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(),"D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空",false);
      querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((querySingleRemoteControllerRedisDetailComRespDto!= null&& querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null )) {
        //if(D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69483

PreparationKpiTargetCalcConfParametersComRespDto preparationKpiTargetCalcConfParametersComRespDto = null;
    PreparationKpiTargetCalcConfParametersComReqDto preparationKpiTargetCalcConfParametersComReqDto=new PreparationKpiTargetCalcConfParametersComReqDto();
  if(reqDto!=null){
      preparationKpiTargetCalcConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837501_1_69484
    }

    /*D2准备绩效目标计算配置参数(公共)[9705]   */
    Assert.isNull(preparationKpiTargetCalcConfParametersComReqDto.getEvaluationTemplateId(),"D2新增绩效目标计算MQ遥控器(公共)-D2准备绩效目标计算配置参数(公共)-冗余评价模板ID不能为空",false);
      preparationKpiTargetCalcConfParametersComRespDto = preparationKpiTargetCalcConfParametersCom(preparationKpiTargetCalcConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;



AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(preparationKpiTargetCalcConfParametersComRespDto !=null){
          AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1837766_1_69485
addRedisBusinessDataSetComReqDto.setBusinessDataObject("KPI_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1837765_1_69485
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1837767_1_69485
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1837768_1_69485
addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1837769_1_69485
addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1837771_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1837772_1_69485
addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1837773_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1837774_1_69485
addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1837775_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1837776_1_69485
addRedisBusinessDataSetComReqDto.setCustomField5("MQ_REMOTE_CONTROLLER_NAME");//CUSTOM_CONVENTION//sourceId:1837777_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue5("KPI_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1837778_1_69485
addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1837779_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1837780_1_69485
addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1837781_1_69485
addRedisBusinessDataSetComReqDto.setCustomField8("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1837783_1_69485
addRedisBusinessDataSetComReqDto.setCustomField9("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1837785_1_69485
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837770_1_69485
    }
if(receptionServiceRes!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(),"yyyy-MM-dd HH:mm:ss"));//SimpleFieldAssign//sourceId:1837782_1_69485
    }
if(preparationKpiTargetCalcConfParametersComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationKpiTargetCalcConfParametersComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837784_1_69485
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(preparationKpiTargetCalcConfParametersComRespDto.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1837786_1_69485
    }

    /*D2增绩效目标计算MQ遥控器Redis[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值9不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }
      }
AddKpiTargetCalcMqRemoteControllerComRespDto retData = new AddKpiTargetCalcMqRemoteControllerComRespDto();





return retData;
  }
/**
   * D2准备OKR目标计算配置参数(公共)[9703]
   * gen by moon at 6/2/2024, 12:24:23 AM
   */
  @Trace(operationName = "D2准备OKR目标计算配置参数(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationOkrTargetCalcConfParametersComRespDto preparationOkrTargetCalcConfParametersCom(PreparationOkrTargetCalcConfParametersComReqDto reqDto){


      ImplementTenReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834894_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2准备OKR目标计算配置参数(公共)-M2接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1834917_1
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1834918_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1834919_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834916_1
    }

    /*D2查询评价模板目标得分配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_1=new ImplementTenReceivingFieldReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      receptionServiceReq_1.setTargetScoreUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1835074_1
    }

    /*M2接收配置参数出参[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetScoreUnit(),"D2准备OKR目标计算配置参数(公共)-M2接收配置参数出参-目标得分单位不能为空",false);
      receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

PreparationOkrTargetCalcConfParametersComRespDto retData = new PreparationOkrTargetCalcConfParametersComRespDto();
  if(receptionServiceRes_2!=null){
      retData.setTargetScoreUnit(receptionServiceRes_2.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1835075_1
    }




return retData;
  }
/**
   * D2准备绩效目标计算配置参数(公共)[9705]
   * gen by moon at 6/2/2024, 12:24:50 AM
   */
  @Trace(operationName = "D2准备绩效目标计算配置参数(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationKpiTargetCalcConfParametersComRespDto preparationKpiTargetCalcConfParametersCom(PreparationKpiTargetCalcConfParametersComReqDto reqDto){


      ImplementTenReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1836483_1
    }

    /*M2接收字段入参[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2准备绩效目标计算配置参数(公共)-M2接收字段入参-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1837324_1
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1837325_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1837326_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837323_1
    }

    /*D2查评价模板目标得分单位配置参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:1837329_1
queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("IS_OPEN_SYMBOLIC_ACHIEVEMENTS");//CUSTOM_CONVENTION//sourceId:1837330_1
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1837331_1
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837328_1
    }

    /*D2查询评价模板是否开启标志性成果配置参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjType(),"D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1)/*vcase invoke isSameApp*/;




//步骤3: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_1=new ImplementTenReceivingFieldReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      receptionServiceReq_1.setTargetScoreUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1837496_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      receptionServiceReq_1.setIsOpenSymbolicAchievements(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1837497_1
    }

    /*M2接收配置参数出参[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetScoreUnit(),"D2准备绩效目标计算配置参数(公共)-M2接收配置参数出参-目标得分单位不能为空",false);
Assert.isNull(receptionServiceReq_1.getIsOpenSymbolicAchievements(),"D2准备绩效目标计算配置参数(公共)-M2接收配置参数出参-是否开启标志性成果不能为空",false);
      receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

PreparationKpiTargetCalcConfParametersComRespDto retData = new PreparationKpiTargetCalcConfParametersComRespDto();
  if(receptionServiceRes_2!=null){
      retData.setTargetScoreUnit(receptionServiceRes_2.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837499_1
retData.setIsOpenSymbolicAchievements(receptionServiceRes_2.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1837500_1
    }




return retData;
  }
/**
   * D2查询单遥控器Redis详情(公共)[9708]
   * gen by moon at 6/9/2024, 9:35:34 PM
   */
  @Trace(operationName = "D2查询单遥控器Redis详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailCom(QuerySingleRemoteControllerRedisDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839409_1
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1839405_1
queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1839406_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1839407_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1839408_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1861427_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1861428_1
    }

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

QuerySingleRemoteControllerRedisDetailComRespDto retData = new QuerySingleRemoteControllerRedisDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839414_1
    }




return retData;
  }
/**
   * D2执行Redis长生守护(公共)[9702]
   * gen by moon at 6/2/2024, 11:03:46 PM
   */
  @Trace(operationName = "D2执行Redis长生守护(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRedisLongevityGuardianComRespDto implementRedisLongevityGuardianCom(ImplementRedisLongevityGuardianComReqDto reqDto){


      //virtualUsage M2约定：Redis业务数据对象  69504
      //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840345_1_69504
receptionServiceReq.setCustomField2("OKR_PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840346_1_69504
receptionServiceReq.setCustomField3("KPI_PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840347_1_69504
receptionServiceReq.setCustomField4("FINANCIAL_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840365_1_69504

    /*M2约定：Redis业务数据对象[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段3不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField4(),"D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段4不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);



//virtualUsage D2查询有排队的遥控器详情(redis)  69495
      QueryQueueingRemoteControllerDetailComRespDto queryQueueingRemoteControllerDetailComRespDto = null;
    QueryQueueingRemoteControllerDetailComReqDto queryQueueingRemoteControllerDetailComReqDto=new QueryQueueingRemoteControllerDetailComReqDto();


    /*D2查询有排队的遥控器详情(redis)[9710]   */

      queryQueueingRemoteControllerDetailComRespDto = queryQueueingRemoteControllerDetailCom(queryQueueingRemoteControllerDetailComReqDto)/*vcase invoke 同服务,同domain*/;



if((queryQueueingRemoteControllerDetailComRespDto!= null&& queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId() != null &&queryQueueingRemoteControllerDetailComRespDto!= null&& Long.valueOf(queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum()) > 0)) {
        //if((D2查询有排队的遥控器详情(redis).评价模板ID 值不等于空  and D2查询有排队的遥控器详情(redis).排队最小值 大于 0))  69496

if((queryQueueingRemoteControllerDetailComRespDto!= null&&  queryQueueingRemoteControllerDetailComRespDto.getMqRemoteControllerName() !=null && queryQueueingRemoteControllerDetailComRespDto.getMqRemoteControllerName().equals("PLAN_TARGET_CALC"))) {
        //if(D2查询有排队的遥控器详情(redis).MQ遥控器名称 等于 规划目标计算)  69499

QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto = null;
    if(queryQueueingRemoteControllerDetailComRespDto !=null){
          QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto=new QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto();
  if(queryQueueingRemoteControllerDetailComRespDto!=null){
      queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto.setEvaluationTemplateId(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1840419_1_69506
    }

    /*D2查询规划目标计算MQ遥控器公共业务数据(Redis)[9711]   */
    Assert.isNull(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto.getEvaluationTemplateId(),"D2执行Redis长生守护(公共)-D2查询规划目标计算MQ遥控器公共业务数据(Redis)-冗余评价模板ID不能为空",false);
      queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto = queryPlanTargetCalcMqRemoteControllerBusinessDataDetailCom(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto)/*vcase invoke 同服务,同domain*/;



           }
QueryRemoteControllerQueueConDataDetailComRespDto queryRemoteControllerQueueConDataDetailComRespDto = null;
    if(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto !=null){
          QueryRemoteControllerQueueConDataDetailComReqDto queryRemoteControllerQueueConDataDetailComReqDto=new QueryRemoteControllerQueueConDataDetailComReqDto();
  if(receptionServiceRes!=null){
      queryRemoteControllerQueueConDataDetailComReqDto.setBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1841105_1_69517
    }
if(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto!=null){
      queryRemoteControllerQueueConDataDetailComReqDto.setDataObjectBatchCode(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1841106_1_69517
queryRemoteControllerQueueConDataDetailComReqDto.setRefCustomFieldValue1(String.valueOf(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getQueueMinimum()));//SimpleFieldAssign//sourceId:1841107_1_69517
    }

    /*D2查询MQ排队计算内容数据详情(公共)[9712]   */
    Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getBusinessDataObject(),"D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-业务数据对象不能为空",false);
Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getDataObjectBatchCode(),"D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-数据对象批次标识不能为空",false);
Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getRefCustomFieldValue1(),"D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-排队值不能为空",false);
      queryRemoteControllerQueueConDataDetailComRespDto = queryRemoteControllerQueueConDataDetailCom(queryRemoteControllerQueueConDataDetailComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((queryRemoteControllerQueueConDataDetailComRespDto!= null&& queryRemoteControllerQueueConDataDetailComRespDto.getTargetAttributionCycleId() != null )) {
        //if(D2查询MQ排队计算内容数据详情(公共).目标归属周期ID 值不等于空 )  69518

ImplementCurQueueOutWriteMiniComRespDto implementCurQueueOutWriteMiniComRespDto = null;
    if(queryQueueingRemoteControllerDetailComRespDto !=null&&queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto !=null){
          ImplementCurQueueOutWriteMiniComReqDto implementCurQueueOutWriteMiniComReqDto=new ImplementCurQueueOutWriteMiniComReqDto();
  implementCurQueueOutWriteMiniComReqDto.setControlBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1842877_1_69527
implementCurQueueOutWriteMiniComReqDto.setCommPrimaryKeyFieldName("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1842882_1_69527
if(receptionServiceRes!=null){
      implementCurQueueOutWriteMiniComReqDto.setQueueBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1842878_1_69527
    }
if(queryQueueingRemoteControllerDetailComRespDto!=null){
      implementCurQueueOutWriteMiniComReqDto.setDataObjectBatchCode(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1842879_1_69527
implementCurQueueOutWriteMiniComReqDto.setCommPrimaryKey(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1842881_1_69527
    }
if(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto!=null){
      implementCurQueueOutWriteMiniComReqDto.setQueueMinimum(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getQueueMinimum());//SimpleFieldAssign//sourceId:1842880_1_69527
    }

    /*D2执行当前排队移出回写最小排队值(redis)[9716]   */
    Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getControlBusinessDataObject(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-MQ遥控器业务数据对象不能为空",false);
Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getQueueBusinessDataObject(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-MQ队列业务数据对象不能为空",false);
Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getDataObjectBatchCode(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-数据对象批次标识不能为空",false);
Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getCommPrimaryKey(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-通用主键ID不能为空",false);
Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getCommPrimaryKeyFieldName(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-通用主键字段名不能为空",false);
Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getQueueMinimum(),"D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-排队最小值不能为空",false);
      implementCurQueueOutWriteMiniComRespDto = implementCurQueueOutWriteMiniCom(implementCurQueueOutWriteMiniComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
else if((queryRemoteControllerQueueConDataDetailComRespDto!= null&& queryRemoteControllerQueueConDataDetailComRespDto.getTargetAttributionCycleId() == null )){
       //elseif(D2查询MQ排队计算内容数据详情(公共).目标归属周期ID 值等于空 )  69519

ImplementRemoteControllerResetZeroComRespDto implementRemoteControllerResetZeroComRespDto = null;
    if(queryQueueingRemoteControllerDetailComRespDto !=null){
          ImplementRemoteControllerResetZeroComReqDto implementRemoteControllerResetZeroComReqDto=new ImplementRemoteControllerResetZeroComReqDto();
  implementRemoteControllerResetZeroComReqDto.setCommPrimaryKeyFieldName("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1846063_1_69544
if(queryQueueingRemoteControllerDetailComRespDto!=null){
      implementRemoteControllerResetZeroComReqDto.setCommPrimaryKey(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1846062_1_69544
    }

    /*D2执行MQ遥控器重置为0(公共)[9722]   */
    Assert.isNull(implementRemoteControllerResetZeroComReqDto.getCommPrimaryKey(),"D2执行Redis长生守护(公共)-D2执行MQ遥控器重置为0(公共)-通用主键ID不能为空",false);
Assert.isNull(implementRemoteControllerResetZeroComReqDto.getCommPrimaryKeyFieldName(),"D2执行Redis长生守护(公共)-D2执行MQ遥控器重置为0(公共)-通用主键字段名不能为空",false);
      implementRemoteControllerResetZeroComRespDto = implementRemoteControllerResetZeroCom(implementRemoteControllerResetZeroComReqDto)/*vcase invoke 同服务,同domain*/;



           }
    }
if((queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto!= null&& queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getCustomField1() == null )) {
        //if(D2查询规划目标计算MQ遥控器公共业务数据(Redis).评价模板ID 值等于空 )  69507

//异常结束 69510
      throw new BizException("C221000450","对不起，找不到当前评价模板ID的规划目标计算的MQ遥控器~",false);
      }
      }
      }
else if((queryQueueingRemoteControllerDetailComRespDto!= null&& queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId() != null &&queryQueueingRemoteControllerDetailComRespDto!= null&&  queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum() !=null && queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum().equals("0"))){
       //elseif((D2查询有排队的遥控器详情(redis).评价模板ID 值不等于空  and D2查询有排队的遥控器详情(redis).排队最小值 等于 0))  69532

//异常结束 69533
      throw new BizException("C221000451","对不起，当前有MQ遥控器的排队，最小排队值不能为0~",false);
    }
ImplementRedisLongevityGuardianComRespDto retData = new ImplementRedisLongevityGuardianComRespDto();





return retData;
  }
/**
   * D2查询有排队的遥控器详情(redis)[9710]
   * gen by moon at 6/9/2024, 9:35:18 PM
   */
  @Trace(operationName = "D2查询有排队的遥控器详情(redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryQueueingRemoteControllerDetailComRespDto queryQueueingRemoteControllerDetailCom(QueryQueueingRemoteControllerDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
ImplementTenReceivingFieldRespDto receptionServiceRes_1 =null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1861437_1
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839737_1
queryRefRedisBusinessDataSetDetailComReqDto.setRedisParamSortType("ASC");//sourceId:1846408_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1839738_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1("TRUE");//CUSTOM_CONVENTION//sourceId:1839739_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839908_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1845575_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1839918_1

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisParamSortType(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-redis出参排序类型不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(),"D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

//步骤1: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    if(queryRefRedisBusinessDataSetDetailComRespDto !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto!=null){
      receptionServiceReq.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()!=null?Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()):null);//SimpleFieldAssign//sourceId:1847191_1
    }

    /*M2接收出参排队最小值[8782]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq.getQueueMinimum(),"D2查询有排队的遥控器详情(redis)-M2接收出参排队最小值-排队最小值不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }

QueryQueueingRemoteControllerDetailComRespDto retData = new QueryQueueingRemoteControllerDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839914_1
retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1839920_1
    }
if(receptionServiceRes_1!=null){
      retData.setQueueMinimum(receptionServiceRes_1.getQueueMinimum()!=null?receptionServiceRes_1.getQueueMinimum().intValue():null);//SimpleFieldAssign//sourceId:1847192_1
    }




return retData;
  }
/**
   * D2查询规划目标计算MQ遥控器公共业务数据(Redis)[9711]
   * gen by moon at 7/2/2024, 3:19:45 AM
   */
  @Trace(operationName = "D2查询规划目标计算MQ遥控器公共业务数据(Redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailCom(QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839900_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-M2接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839616_1
queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839498_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839500_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839508_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1839509_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1839510_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1839511_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1839512_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1839513_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1839514_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1839515_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1839516_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("isOpenFinance");//CUSTOM_CONVENTION//sourceId:1839517_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("schemeDataPara");//CUSTOM_CONVENTION//sourceId:1839518_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField12("isOkrPlanScene");//CUSTOM_CONVENTION//sourceId:1839519_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField13("reportType");//CUSTOM_CONVENTION//sourceId:1839520_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField14("cycleMode");//CUSTOM_CONVENTION//sourceId:1839521_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField15("fatherCycleType");//CUSTOM_CONVENTION//sourceId:1839522_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField16("subcycleType");//CUSTOM_CONVENTION//sourceId:1839523_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField17("midCycleType");//CUSTOM_CONVENTION//sourceId:1839524_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField18("openMidCycle");//CUSTOM_CONVENTION//sourceId:1839525_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField19("lastCycleType");//CUSTOM_CONVENTION//sourceId:1839526_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField20("secondLastCycleType");//CUSTOM_CONVENTION//sourceId:1839527_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField21("isOpenMidProcess");//CUSTOM_CONVENTION//sourceId:1839528_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField22("processMidCycleType");//CUSTOM_CONVENTION//sourceId:1839529_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField23("isOpenSubReportLimit");//CUSTOM_CONVENTION//sourceId:1839530_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField24("constTaskIsOpenReport");//CUSTOM_CONVENTION//sourceId:1839531_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField25("constIsOpenAtuoReport");//CUSTOM_CONVENTION//sourceId:1839532_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField26("noPracticalValueObjIsProgReport");//CUSTOM_CONVENTION//sourceId:1839533_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField27("objectiveActualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1839534_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField28("actualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1839535_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField29("actualScoreFormula");//CUSTOM_CONVENTION//sourceId:1839536_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField30("subjectiveRatingTotalValue");//CUSTOM_CONVENTION//sourceId:1839537_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField31("subjectiveFullMarkUnit");//CUSTOM_CONVENTION//sourceId:1839538_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField32("scoreDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839539_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField33("degreeDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839540_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField34("progressDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839541_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField35("subjectiveScorePoint");//CUSTOM_CONVENTION//sourceId:1839542_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField36("weightPoint");//CUSTOM_CONVENTION//sourceId:1839543_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField37("weightDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839544_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField38("increasesDropDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839545_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField39("actualValueDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839546_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField40("decimalDigitsLastRules");//CUSTOM_CONVENTION//sourceId:1839547_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField41("subjectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1839548_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField42("objectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1839549_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField43("processReportScoreMidWeight");//CUSTOM_CONVENTION//sourceId:1839550_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField44("processReportScoreProMidWeight");//CUSTOM_CONVENTION//sourceId:1839551_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField45("processReportScoreAvgWeight");//CUSTOM_CONVENTION//sourceId:1839552_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField46("reportScoreSubAndObjWeight");//CUSTOM_CONVENTION//sourceId:1839553_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField47("actualScoreLocalLevelWeight");//CUSTOM_CONVENTION//sourceId:1839554_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField48("actualScoreLowerLevelWeight");//CUSTOM_CONVENTION//sourceId:1839555_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField49("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1839556_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField50("isOpenBudget");//CUSTOM_CONVENTION//sourceId:1839557_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField51("isOpenBudgetReport");//CUSTOM_CONVENTION//sourceId:1840373_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField52("useAccountSubjectType");//CUSTOM_CONVENTION//sourceId:1840374_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField53("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1840375_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField54("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1840376_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField55("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1840377_1
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839608_1
    }

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField12(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段12不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField13(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段13不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField14(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段14不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField15(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段15不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField16(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段16不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField17(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段17不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField18(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段18不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField19(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段19不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField20(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段20不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField21(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段21不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField22(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段22不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField23(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段23不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField24(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段24不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField25(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段25不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField26(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段26不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField27(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段27不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField28(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段28不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField29(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段29不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField30(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段30不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField31(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段31不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField32(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段32不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField33(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段33不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField34(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段34不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField35(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段35不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField36(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段36不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField37(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段37不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField38(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段38不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField39(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段39不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField40(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段40不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField41(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段41不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField42(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段42不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField43(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段43不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField44(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段44不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField45(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段45不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField46(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段46不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField47(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段47不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField48(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段48不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField49(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段49不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField50(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段50不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField51(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段51不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField52(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段52不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField53(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段53不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField54(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段54不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField55(),"D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段55不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto retData = new QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setCustomField1(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839902_1
retData.setQueueMinimum(Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2()));//SimpleFieldAssign//sourceId:1839903_1
retData.setQueueMaximum(Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3()));//SimpleFieldAssign//sourceId:1839904_1
retData.setIsQueueCurrently(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1839905_1
retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1839906_1
retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1839907_1
retData.setOperateTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1839910_1
retData.setIsAllowBudgetOverruns(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1839913_1
retData.setCashAccountUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1839916_1
retData.setIsOpenFinance(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1839917_1
retData.setSchemeDataPara(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1839929_1
retData.setIsOkrPlanScene(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField12());//SimpleFieldAssign//sourceId:1839930_1
retData.setReportType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField13());//SimpleFieldAssign//sourceId:1839931_1
retData.setCycleMode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField14());//SimpleFieldAssign//sourceId:1839932_1
retData.setFatherCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField15());//SimpleFieldAssign//sourceId:1839933_1
retData.setSubCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField16());//SimpleFieldAssign//sourceId:1839934_1
retData.setMidCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField17());//SimpleFieldAssign//sourceId:1839935_1
retData.setOpenMidCycle(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField18());//SimpleFieldAssign//sourceId:1839936_1
retData.setLastCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField19());//SimpleFieldAssign//sourceId:1839937_1
retData.setSecondLastCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField20());//SimpleFieldAssign//sourceId:1839938_1
retData.setIsOpenMidProcess(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField21());//SimpleFieldAssign//sourceId:1839939_1
retData.setProcessMidCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField22());//SimpleFieldAssign//sourceId:1839940_1
retData.setIsOpenSubReportLimit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField23());//SimpleFieldAssign//sourceId:1839941_1
retData.setConstTaskIsOpenReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField24());//SimpleFieldAssign//sourceId:1839942_1
retData.setConstIsOpenAtuoReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField25());//SimpleFieldAssign//sourceId:1839943_1
retData.setNoPracticalValueObjIsProgReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField26());//SimpleFieldAssign//sourceId:1839944_1
retData.setObjectiveActualScoreIsOpenLocalLevelScore(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField27());//SimpleFieldAssign//sourceId:1839945_1
retData.setActualScoreIsOpenLocalLevelScore(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField28());//SimpleFieldAssign//sourceId:1839946_1
retData.setActualScoreFormula(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField29());//SimpleFieldAssign//sourceId:1839947_1
retData.setSubjectiveRatingTotalValue(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField30());//SimpleFieldAssign//sourceId:1839948_1
retData.setSubjectiveFullMarkUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField31());//SimpleFieldAssign//sourceId:1839949_1
retData.setScoreDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField32());//SimpleFieldAssign//sourceId:1840022_1
retData.setDegreeDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField33());//SimpleFieldAssign//sourceId:1840023_1
retData.setProgressDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField34());//SimpleFieldAssign//sourceId:1840078_1
retData.setSubjectiveScorePoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField35());//SimpleFieldAssign//sourceId:1840086_1
retData.setWeightPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField36());//SimpleFieldAssign//sourceId:1840087_1
retData.setWeightDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField37());//SimpleFieldAssign//sourceId:1840088_1
retData.setIncreasesDropDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField38());//SimpleFieldAssign//sourceId:1840161_1
retData.setActualValueDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField39());//SimpleFieldAssign//sourceId:1840168_1
retData.setDecimalDigitsLastRules(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField40());//SimpleFieldAssign//sourceId:1840172_1
retData.setSubjectiveScoreWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField41());//SimpleFieldAssign//sourceId:1840173_1
retData.setObjectiveScoreWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField42());//SimpleFieldAssign//sourceId:1840177_1
retData.setProcessReportScoreMidWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField43());//SimpleFieldAssign//sourceId:1840179_1
retData.setProcessReportScoreProMidWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField44());//SimpleFieldAssign//sourceId:1840180_1
retData.setProcessReportScoreAvgWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField45());//SimpleFieldAssign//sourceId:1840181_1
retData.setReportScoreSubAndObjWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField46());//SimpleFieldAssign//sourceId:1840342_1
retData.setActualScoreLocalLevelWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField47());//SimpleFieldAssign//sourceId:1840343_1
retData.setActualScoreLowerLevelWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField48());//SimpleFieldAssign//sourceId:1840344_1
retData.setIsOpenSymbolicAchievements(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField49());//SimpleFieldAssign//sourceId:1840351_1
retData.setIsOpenBudget(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField50());//SimpleFieldAssign//sourceId:1840352_1
retData.setIsOpenBudgetReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField51());//SimpleFieldAssign//sourceId:1840414_1
retData.setUseAccountSubjectType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField52());//SimpleFieldAssign//sourceId:1840415_1
retData.setIsOpenFundsArrival(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField53());//SimpleFieldAssign//sourceId:1840416_1
retData.setIsAllowBudgetOverruns(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField54());//SimpleFieldAssign//sourceId:1840417_1
retData.setTargetScoreUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField55());//SimpleFieldAssign//sourceId:1840418_1
    }




return retData;
  }
/**
   * D2查询MQ排队计算内容数据详情(公共)[9712]
   * gen by moon at 6/6/2024, 3:47:40 PM
   */
  @Trace(operationName = "D2查询MQ排队计算内容数据详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryRemoteControllerQueueConDataDetailComRespDto queryRemoteControllerQueueConDataDetailCom(QueryRemoteControllerQueueConDataDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841072_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1841073_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("targetAttributionCycleId");//CUSTOM_CONVENTION//sourceId:1841083_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("isLastCycle");//CUSTOM_CONVENTION//sourceId:1841084_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("spaceId");//CUSTOM_CONVENTION//sourceId:1852115_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("appId");//CUSTOM_CONVENTION//sourceId:1852116_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1852117_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1852118_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("updateCycleId");//CUSTOM_CONVENTION//sourceId:1852119_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1852120_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1852121_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1852122_1
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1841071_1
queryRefRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1841079_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1841074_1
    }

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(),"D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

QueryRemoteControllerQueueConDataDetailComRespDto retData = new QueryRemoteControllerQueueConDataDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setTargetAttributionCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1841098_1
retData.setIsLastCycle(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1841099_1
retData.setSpaceId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1849435_1
retData.setAppId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1849436_1
retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1849437_1
retData.setPreUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1852128_1
retData.setUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1852129_1
retData.setUpdateCycleStartTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1852130_1
retData.setUpdateCycleEndTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1852131_1
retData.setUpdateCycleTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1852132_1
    }




return retData;
  }
/**
   * D2执行当前排队移出回写最小排队值(redis)[9716]
   * gen by moon at 6/6/2024, 8:52:02 PM
   */
  @Trace(operationName = "D2执行当前排队移出回写最小排队值(redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCurQueueOutWriteMiniComRespDto implementCurQueueOutWriteMiniCom(ImplementCurQueueOutWriteMiniComReqDto reqDto){


      //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setControlBusinessDataObject(reqDto.getControlBusinessDataObject());//SimpleFieldAssign//sourceId:1842070_1
receptionServiceReq.setQueueBusinessDataObject(reqDto.getQueueBusinessDataObject());//SimpleFieldAssign//sourceId:1842071_1
receptionServiceReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1842067_1
receptionServiceReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1842869_1
receptionServiceReq.setCommPrimaryKeyFieldName(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1842875_1
receptionServiceReq.setQueueMinimum(reqDto.getQueueMinimum()!=null?Integer.valueOf(reqDto.getQueueMinimum()):null);//SimpleFieldAssign//sourceId:1842866_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getControlBusinessDataObject(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-MQ遥控器业务数据对象不能为空",false);
Assert.isNull(receptionServiceReq.getQueueBusinessDataObject(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-MQ队列业务数据对象不能为空",false);
Assert.isNull(receptionServiceReq.getDataObjectBatchCode(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-数据对象批次标识不能为空",false);
Assert.isNull(receptionServiceReq.getCommPrimaryKey(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-通用主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getCommPrimaryKeyFieldName(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-通用主键字段名不能为空",false);
Assert.isNull(receptionServiceReq.getQueueMinimum(),"D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-排队最小值不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2删除redis业务数据对象(业务原子) - deleteRedisBusinessDataSetCom
     DeleteRedisBusinessDataSetComRespDto deleteRedisBusinessDataSetComRespDto = null;
    DeleteRedisBusinessDataSetComReqDto deleteRedisBusinessDataSetComReqDto=new DeleteRedisBusinessDataSetComReqDto();
  deleteRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841880_1
deleteRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1841883_1
deleteRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1841884_1
if(reqDto!=null){
      deleteRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getQueueBusinessDataObject());//SimpleFieldAssign//sourceId:1841881_1
deleteRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1841882_1
deleteRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueMinimum()!=null?String.valueOf(reqDto.getQueueMinimum()):"");//SimpleFieldAssign//sourceId:1841885_1
    }

    /*D2删除MQ排队当前值的队列数据[9717]   */
    Assert.isNull(deleteRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-Redis数据对象目录不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-业务数据对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getDataObjectBatchCode(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-数据对象批次标识不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getIsDataList(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-是否是数据集对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getCustomField1(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-自定义字段1不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-自定义字段值1不能为空",false);
      deleteRedisBusinessDataSetComRespDto = businessAtomService.deleteRedisBusinessDataSetCom(deleteRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2-计算两个数值相加(公共) - calculateAdditionOfTwoNumsCom
     CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto = null;
    CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto=new CalculateAdditionOfTwoNumsComReqDto();
  calculateAdditionOfTwoNumsComReqDto.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1842872_1
if(reqDto!=null){
      calculateAdditionOfTwoNumsComReqDto.setCalcPara1(reqDto.getQueueMinimum()!=null?Double.valueOf(reqDto.getQueueMinimum()):null);//SimpleFieldAssign//sourceId:1842871_1
    }

    /*D2当前排队最小值+1[8137]   */
    Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara1(),"D2执行当前排队移出回写最小排队值(redis)-D2当前排队最小值+1-计算入参1不能为空",false);
Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara2(),"D2执行当前排队移出回写最小排队值(redis)-D2当前排队最小值+1-计算入参2不能为空",false);
      calculateAdditionOfTwoNumsComRespDto = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto)/*vcase invoke isSameApp*/;




//步骤3: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
    if(calculateAdditionOfTwoNumsComRespDto !=null){
          ImplementTenReceivingFieldReqDto receptionServiceReq_1=new ImplementTenReceivingFieldReqDto();
    if(calculateAdditionOfTwoNumsComRespDto !=null){
        // TODO: 2024/6/6  
      receptionServiceReq_1.setQueueMinimum(calculateAdditionOfTwoNumsComRespDto.getCalcResult()!=null?calculateAdditionOfTwoNumsComRespDto.getCalcResult().intValue():null);//SimpleFieldAssign//sourceId:1853010_1
    }

    /*M2接收排队最小值（小数转整数，接口锁定）[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getQueueMinimum(),"D2执行当前排队移出回写最小排队值(redis)-M2接收排队最小值（小数转整数，接口锁定）-排队最小值不能为空",false);
      receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);



           }

//步骤4: D2修改redis业务数据对象(业务原子) - updateRedisBusinessDataSetCom
     UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
          UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841900_1
updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1841902_1
updateRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1841905_1
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getControlBusinessDataObject());//SimpleFieldAssign//sourceId:1841901_1
updateRedisBusinessDataSetComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1841903_1
updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1841904_1
    }
if(receptionServiceRes_1!=null){
      updateRedisBusinessDataSetComReqDto.setCustomFieldValue2(receptionServiceRes_1.getQueueMinimum()!=null?String.valueOf(receptionServiceRes_1.getQueueMinimum()):"");//SimpleFieldAssign//sourceId:1841906_1
    }

    /*D2修改MQ遥控器排队值[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-是否是数据集对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-入参自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-入参自定义字段值1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-自定义字段2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-自定义字段值2不能为空",false);
      updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;




ImplementCurQueueOutWriteMiniComRespDto retData = new ImplementCurQueueOutWriteMiniComRespDto();





return retData;
  }
/**
   * D2执行MQ遥控器重置为0(公共)[9722]
   * gen by moon at 6/8/2024, 8:04:37 PM
   */
  @Trace(operationName = "D2执行MQ遥控器重置为0(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRemoteControllerResetZeroComRespDto implementRemoteControllerResetZeroCom(ImplementRemoteControllerResetZeroComReqDto reqDto){


      //virtualUsage D2执行分布式加锁  69529
      ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1843207_1_69529
implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("MQ_HOVER_QUEUE_LOCK");//sourceId:1843197_1_69529
implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1843196_1_69529
implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1843202_1_69529
implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1843203_1_69529
implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1843204_1_69529
implementConcBhvThemeLockComComReqDto.setWhetherUnlockBulk("FALSE");//sourceId:1843205_1_69529
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1843198_1_69529
    }

    /*D2执行分布式加锁[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto.getRedisDataObjectCatalogue(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-锁定时长不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-时间单位类型不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-并发上锁失败处理方式不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto.getWhetherUnlockBulk(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-是否批量解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto = interfaceModeService.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto)/*vcase invoke isSameApp*/;



if((implementConcBhvThemeLockComComRespDto!= null&&  implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行分布式加锁.防并发上锁情况 等于 空上锁成功)  69530

QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1846051_1_69540
queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1846050_1_69540
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1846054_1_69540
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1846055_1_69540
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1846052_1_69540
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1846053_1_69540
    }

    /*D2查上锁后的MQ遥控器当前最小最大值[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-自定义字段3不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;



ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
    if(queryRefRedisBusinessDataSetDetailComRespDto !=null){
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto=new ImplementNumericalContrastMagnitudeComReqDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara1(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()!=null?Double.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()):null);//SimpleFieldAssign//sourceId:1846059_1_69541
implementNumericalContrastMagnitudeComReqDto.setCalcPara2(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()!=null?Double.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()):null);//SimpleFieldAssign//sourceId:1846060_1_69541
    }

    /*D2执行两个数值对比大小(公共)[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(),"D2执行MQ遥控器重置为0(公共)-D2执行两个数值对比大小(公共)-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(),"D2执行MQ遥控器重置为0(公共)-D2执行两个数值对比大小(公共)-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto = interfaceModeService.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto)/*vcase invoke isSameApp*/;



           }
if((implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("LATER"))) {
        //if(D2当前排队最小值与最大值比大小.数值比较结果 等于 之后（大于）)  69542

UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
    UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto=new UpdateRedisBusinessDataSetComReqDto();
  updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1845581_1_69543
updateRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1845582_1_69543
updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1845583_1_69543
updateRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1845586_1_69543
updateRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1845587_1_69543
updateRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1845588_1_69543
updateRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1845589_1_69543
updateRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1846066_1_69543
updateRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1846067_1_69543
if(reqDto!=null){
      updateRedisBusinessDataSetComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1845584_1_69543
updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1845585_1_69543
    }

    /*D2修改redis业务数据对象(业务原子)[9407]   */
    Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-Redis数据对象目录不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-业务数据对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-是否是数据集对象不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-入参自定义字段1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-入参自定义字段值1不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField3(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段3不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField4(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段4不能为空",false);
Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值4不能为空",false);
      updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
    ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1=new ImplementConcBhvThemeLockComComReqDto();
  implementConcBhvThemeLockComComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1843219_1_69768
implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("MQ_HOVER_QUEUE_LOCK");//sourceId:1843209_1_69768
implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1843208_1_69768
if(reqDto!=null){
      implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1843210_1_69768
    }

    /*D2执行分布式解锁[8388]   */
    Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getRedisDataObjectCatalogue(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-行为主题锁业务数据对象不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-通用主键ID不能为空",false);
Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(),"D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-防并发上锁or解锁不能为空",false);
      implementConcBhvThemeLockComComRespDto_2 = interfaceModeService.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1)/*vcase invoke isSameApp*/;



      }
ImplementRemoteControllerResetZeroComRespDto retData = new ImplementRemoteControllerResetZeroComRespDto();





return retData;
  }
/**
   * D2新增规划财务MQ排队(redis)[9695]
   * gen by moon at 7/2/2024, 3:20:08 AM
   */
  @Trace(operationName = "D2新增规划财务MQ排队(redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddFinancialPlannMqQueueRedisComRespDto addFinancialPlannMqQueueRedisCom(AddFinancialPlannMqQueueRedisComReqDto reqDto){


      //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850958_1
receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855393_1
receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855394_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2新增规划财务MQ排队(redis)-M2接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(),"D2新增规划财务MQ排队(redis)-M2接收入参字段-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(),"D2新增规划财务MQ排队(redis)-M2接收入参字段-更新周期结束时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:1855389_1
    }

    /*D2更新周期开始时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D2新增规划财务MQ排队(redis)-D2更新周期开始时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:1855391_1
    }

    /*D2更新周期结束时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(),"D2新增规划财务MQ排队(redis)-D2更新周期结束时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1)/*vcase invoke isSameApp*/;




//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
     AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    if(implementTimeFormatConversionComRespDto !=null){
    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850921_1
addRedisBusinessDataSetComReqDto.setBusinessDataObject("FINANCIAL_CALC_MQ_QUEUE");//sourceId:1850919_1
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1850922_1
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1850925_1
addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1850926_1
addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1850928_1
addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:1850930_1
addRedisBusinessDataSetComReqDto.setCustomField4("belongToContentId");//CUSTOM_CONVENTION//sourceId:1850932_1
addRedisBusinessDataSetComReqDto.setCustomField5("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1850934_1
addRedisBusinessDataSetComReqDto.setCustomField6("spaceId");//CUSTOM_CONVENTION//sourceId:1850936_1
addRedisBusinessDataSetComReqDto.setCustomField7("accountId");//CUSTOM_CONVENTION//sourceId:1850938_1
addRedisBusinessDataSetComReqDto.setCustomField8("totalBudgetAmount");//CUSTOM_CONVENTION//sourceId:1850940_1
addRedisBusinessDataSetComReqDto.setCustomField9("isBudgetAccount");//CUSTOM_CONVENTION//sourceId:1850942_1
addRedisBusinessDataSetComReqDto.setCustomField10("isIncomingAccount");//CUSTOM_CONVENTION//sourceId:1850944_1
addRedisBusinessDataSetComReqDto.setCustomField11("isStatisticalAccount");//CUSTOM_CONVENTION//sourceId:1850946_1
addRedisBusinessDataSetComReqDto.setCustomField13("appId");//CUSTOM_CONVENTION//sourceId:1850954_1
addRedisBusinessDataSetComReqDto.setCustomField14("operationInductionId");//CUSTOM_CONVENTION//sourceId:1850956_1
addRedisBusinessDataSetComReqDto.setCustomField12("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1850952_1
addRedisBusinessDataSetComReqDto.setCustomField15("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1851402_1
addRedisBusinessDataSetComReqDto.setCustomField16("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1851404_1
addRedisBusinessDataSetComReqDto.setCustomField17("entityId");//CUSTOM_CONVENTION//sourceId:1915359_1
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850920_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1850927_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1850929_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1850931_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1850933_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850935_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1850937_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1850939_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1850941_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:1850943_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:1850945_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1850947_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getCustomFieldValue13());//SimpleFieldAssign//sourceId:1850955_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getCustomFieldValue14());//SimpleFieldAssign//sourceId:1850957_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getCustomFieldValue16());//SimpleFieldAssign//sourceId:1851405_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getCustomFieldValue17());//SimpleFieldAssign//sourceId:1915360_1
    }
if(implementTimeFormatConversionComRespDto!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue12(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1850953_1
    }
if(implementTimeFormatConversionComRespDto_2!=null){
      addRedisBusinessDataSetComReqDto.setCustomFieldValue15(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1851403_1
    }

    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段17不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(),"D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;



           }

AddFinancialPlannMqQueueRedisComRespDto retData = new AddFinancialPlannMqQueueRedisComRespDto();





return retData;
  }
/**
   * D2执行规划财务MQ排队(redis)[9742]
   * gen by moon at 7/2/2024, 3:20:15 AM
   */
  @Trace(operationName = "D2执行规划财务MQ排队(redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFinancialPlannMqQueueComRespDto implementFinancialPlannMqQueueCom(ImplementFinancialPlannMqQueueComReqDto reqDto){


      //virtualUsage D2执行并发行为主题锁(悬停等待)-上锁  69662
      ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto = null;
    ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto=new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
  implementConcurrencyBehaviorThemeLockWaitComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850594_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1850595_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1850597_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitingTime("10");//CUSTOM_CONVENTION//sourceId:1850598_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitTimeUnitType("MINUTES");//sourceId:1850599_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1850600_1_69662
implementConcurrencyBehaviorThemeLockWaitComReqDto.setTimeUnitType("MINUTES");//sourceId:1850601_1_69662
if(reqDto!=null){
      implementConcurrencyBehaviorThemeLockWaitComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850596_1_69662
    }

    /*D2执行并发行为主题锁(悬停等待)-上锁[9699]   */
    Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getRedisDataObjectCatalogue(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getBusinessDataObject(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-业务数据对象不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDataObjectBatchCode(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-数据对象批次标识不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getPreventConcurrentLockingUnlocking(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-防并发上锁or解锁不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getWaitingTime(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-等待时长不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getWaitTimeUnitType(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-等待时间单位类型不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDuration(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-锁定时长不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getTimeUnitType(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-时间单位类型不能为空",false);
      implementConcurrencyBehaviorThemeLockWaitComRespDto = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto)/*vcase invoke isSameApp*/;



if((implementConcurrencyBehaviorThemeLockWaitComRespDto!= null&&  implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations() !=null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
        //if(D2执行并发行为主题锁(悬停等待)-上锁.防并发上锁情况 等于 空上锁成功)  69663

UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueComRespDto = null;
    UpdateRemoteControllerMqQueueComReqDto updateRemoteControllerMqQueueComReqDto=new UpdateRemoteControllerMqQueueComReqDto();
  updateRemoteControllerMqQueueComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1850778_1_69664
if(reqDto!=null){
      updateRemoteControllerMqQueueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850779_1_69664
    }

    /*D2遥控器MQ排队(修改单条redis)[9693]   */
    Assert.isNull(updateRemoteControllerMqQueueComReqDto.getBusinessDataObject(),"D2执行规划财务MQ排队(redis)-D2遥控器MQ排队(修改单条redis)-业务数据对象不能为空",false);
Assert.isNull(updateRemoteControllerMqQueueComReqDto.getEvaluationTemplateId(),"D2执行规划财务MQ排队(redis)-D2遥控器MQ排队(修改单条redis)-冗余评价模板ID不能为空",false);
      updateRemoteControllerMqQueueComRespDto = updateRemoteControllerMqQueueCom(updateRemoteControllerMqQueueComReqDto)/*vcase invoke 同服务,同domain*/;



if((updateRemoteControllerMqQueueComRespDto!= null&& updateRemoteControllerMqQueueComRespDto.getQueueMinimum() != null &&updateRemoteControllerMqQueueComRespDto!= null&& updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null )) {
        //if((D2遥控器MQ排队(修改单条redis).排队最小值 值不等于空  and D2遥控器MQ排队(修改单条redis).排队最大值 值不等于空 ))  69665

AddFinancialPlannMqQueueRedisComRespDto addFinancialPlannMqQueueRedisComRespDto = null;
    if(updateRemoteControllerMqQueueComRespDto !=null){
          AddFinancialPlannMqQueueRedisComReqDto addFinancialPlannMqQueueRedisComReqDto=new AddFinancialPlannMqQueueRedisComReqDto();
  addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue13(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1850986_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue14(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1850987_1_69666
if(updateRemoteControllerMqQueueComRespDto!=null){
      addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue1(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()!=null?String.valueOf(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()):"");//SimpleFieldAssign//sourceId:1850975_1_69666
    }
if(reqDto!=null){
      addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1850976_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1851440_1_69666
addFinancialPlannMqQueueRedisComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855397_1_69666
addFinancialPlannMqQueueRedisComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855398_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue16(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1851409_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue4(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1850978_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue17(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1915362_1_69666
addFinancialPlannMqQueueRedisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850974_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue6(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1850979_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue7(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1850980_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue8(reqDto.getTotalBudgetAmount()!=null?String.valueOf(reqDto.getTotalBudgetAmount()):"");//SimpleFieldAssign//sourceId:1850981_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue9(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1850982_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue10(reqDto.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1850983_1_69666
addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue11(reqDto.getIsStatisticalAccount());//SimpleFieldAssign//sourceId:1850984_1_69666
    }

    /*D2新增规划财务MQ排队(redis)[9695]   */
    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue1(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-排队值不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue3(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getUpdateCycleStartTime(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期开始时间不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getUpdateCycleEndTime(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期结束时间不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue16(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期类型标识不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue4(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-数据归属内容表主键ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue17(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-归属内容表主键ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getEvaluationTemplateId(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-冗余评价模板ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue6(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-空间ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue7(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-账户ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue8(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-累计收入金额不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue9(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-是否预算账户不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue11(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-是否统计账户不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue13(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-联盟应用ID不能为空",false);
Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue14(),"D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-操作人就职记录ID不能为空",false);
      addFinancialPlannMqQueueRedisComRespDto = addFinancialPlannMqQueueRedisCom(addFinancialPlannMqQueueRedisComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = null;
    ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto_1=new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
  implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850784_1_69668
implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1850785_1_69668
implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1850787_1_69668
if(reqDto!=null){
      implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850786_1_69668
    }

    /*D2执行并发行为主题锁(悬停等待)-解锁[9699]   */
    Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getRedisDataObjectCatalogue(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-Redis数据对象目录不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getBusinessDataObject(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-业务数据对象不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getDataObjectBatchCode(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-数据对象批次标识不能为空",false);
Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getPreventConcurrentLockingUnlocking(),"D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-防并发上锁or解锁不能为空",false);
      implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto_1)/*vcase invoke isSameApp*/;



      }
ImplementFinancialPlannMqQueueComRespDto retData = new ImplementFinancialPlannMqQueueComRespDto();





return retData;
  }
/**
   * D2查询规划财务MQ排队详情(公共)[9745]
   * gen by moon at 7/2/2024, 3:20:22 AM
   */
  @Trace(operationName = "D2查询规划财务MQ排队详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryFinancialPlannMqQueueDetailComRespDto queryFinancialPlannMqQueueDetailCom(QueryFinancialPlannMqQueueDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1851582_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1851584_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1851586_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:1851587_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1851588_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1851589_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1851590_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("belongToContentId");//CUSTOM_CONVENTION//sourceId:1851591_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1851592_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("spaceId");//CUSTOM_CONVENTION//sourceId:1851593_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("accountId");//CUSTOM_CONVENTION//sourceId:1851594_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("totalBudgetAmount");//CUSTOM_CONVENTION//sourceId:1851595_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("isBudgetAccount");//CUSTOM_CONVENTION//sourceId:1851596_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField12("isIncomingAccount");//CUSTOM_CONVENTION//sourceId:1851597_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField13("isStatisticalAccount");//CUSTOM_CONVENTION//sourceId:1851598_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField14("appId");//CUSTOM_CONVENTION//sourceId:1851660_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField15("operationInductionId");//CUSTOM_CONVENTION//sourceId:1851661_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField16("entityId");//CUSTOM_CONVENTION//sourceId:1915372_1
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1851581_1
queryRefRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1851583_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1851585_1
    }

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField12(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段12不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField13(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段13不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField14(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段14不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField15(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段15不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField16(),"D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段16不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

QueryFinancialPlannMqQueueDetailComRespDto retData = new QueryFinancialPlannMqQueueDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setPreUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1851615_1
retData.setUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1851616_1
retData.setUpdateCycleStartTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1855379_1
retData.setUpdateCycleEndTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1855380_1
retData.setUpdateCycleTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1851619_1
retData.setBelongToContentId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1851620_1
retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1851621_1
retData.setSpaceId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1851622_1
retData.setAccountId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1851623_1
retData.setTotalBudgetAmount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1851624_1
retData.setIsBudgetAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1851625_1
retData.setIsIncomingAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField12());//SimpleFieldAssign//sourceId:1851626_1
retData.setIsStatisticalAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField13());//SimpleFieldAssign//sourceId:1851627_1
retData.setAppId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField14());//SimpleFieldAssign//sourceId:1851664_1
retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField15());//SimpleFieldAssign//sourceId:1851665_1
retData.setEntityId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField16());//SimpleFieldAssign//sourceId:1915374_1
    }




return retData;
  }
/**
   * D2新增公共字段(推内存)[9752]
   * gen by moon at 6/6/2024, 3:48:43 PM
   */
  @Trace(operationName = "D2新增公共字段(推内存)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddCommonDataComRespDto addCommonDataCom(AddCommonDataComReqDto reqDto){


      //步骤0: D2新增内存业务数据(业务原子) - addMemoryBusiness2DataCom
     AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto = null;
    AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto=new AddMemoryBusiness2DataComReqDto();
  addMemoryBusiness2DataComReqDto.setIsDataList("FALSE");//sourceId:1852616_1
addMemoryBusiness2DataComReqDto.setCustomField1("spaceId");//CUSTOM_CONVENTION//sourceId:1852617_1
addMemoryBusiness2DataComReqDto.setCustomField2("appId");//CUSTOM_CONVENTION//sourceId:1852619_1
addMemoryBusiness2DataComReqDto.setCustomField3("operationInductionId");//CUSTOM_CONVENTION//sourceId:1852621_1
if(reqDto!=null){
      addMemoryBusiness2DataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1852614_1
addMemoryBusiness2DataComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1852615_1
addMemoryBusiness2DataComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1852618_1
addMemoryBusiness2DataComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1852620_1
addMemoryBusiness2DataComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1852622_1
    }

    /*D2新增内存业务数据(业务原子)[9751]   */
    Assert.isNull(addMemoryBusiness2DataComReqDto.getDataObjectBatchCode(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getBusinessDataObject(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-业务数据对象不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getIsDataList(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField1(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue1(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField2(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue2(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField3(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue3(),"D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值3不能为空",false);
      addMemoryBusiness2DataComRespDto = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto)/*vcase invoke isSameApp*/;




AddCommonDataComRespDto retData = new AddCommonDataComRespDto();





return retData;
  }
/**
   * D2查询规划财务MQ遥控器详情(redis)[9786]
   * gen by moon at 7/2/2024, 3:20:28 AM
   */
  @Trace(operationName = "D2查询规划财务MQ遥控器详情(redis)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryFinancialPlannMqRemoteControllerDetailComRespDto queryFinancialPlannMqRemoteControllerDetailCom(QueryFinancialPlannMqRemoteControllerDetailComReqDto reqDto){


      QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 =null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
     //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
    ImplementTenReceivingFieldReqDto receptionServiceReq=new ImplementTenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1861769_1
    }

    /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D2查询规划财务MQ遥控器详情(redis)-M2接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);




//步骤1: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
     QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
    QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto=new QueryRefRedisBusinessDataSetDetailComReqDto();
  queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1861571_1
queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1861570_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1861572_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861772_1
queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue2("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1861773_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1861574_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1861575_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1861576_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1861577_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861578_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1861579_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1861580_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1861581_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1861582_1
queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:1915606_1
if(reqDto!=null){
      queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1861573_1
    }

    /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
    Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField2(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue2(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空",false);
Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(),"D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空",false);
      queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

QueryFinancialPlannMqRemoteControllerDetailComRespDto retData = new QueryFinancialPlannMqRemoteControllerDetailComRespDto();
  if(queryRefRedisBusinessDataSetDetailComRespDto_1!=null){
      retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1861783_1
retData.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1861784_1
retData.setQueueMaximum(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1861785_1
retData.setIsQueueCurrently(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1861786_1
retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1861787_1
retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1861788_1
retData.setOperateTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1861789_1
retData.setIsOpenFundsArrival(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1861790_1
retData.setCashAccountUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1861791_1
retData.setPeriodicModeTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1915608_1
    }




return retData;
  }
  //
}
